@hybridcore/ui 1.6.13 → 1.6.16

package/dist/Source-BSZST_GH.js

@@ -0,0 +1,4410 @@
+import { a as S, z as K, w as k, W as ye, B as H, C as Me, b as E, s as L, d as Ce, G as Ee, y as Ie, e as Se, m as p, q as Ut, V as pe, u as it, l as st, E as St } from "./math-Bvt2Ubuz.js";
+function Ae(e) {
+  return Math.pow(e, 3);
+}
+function we(e) {
+  return 1 - Ae(1 - e);
+}
+function Te(e) {
+  return 3 * e * e - 2 * e * e * e;
+}
+function jn(e) {
+  return e;
+}
+const C = {
+  UNKNOWN: 0,
+  INTERSECTING: 1,
+  ABOVE: 2,
+  RIGHT: 4,
+  BELOW: 8,
+  LEFT: 16
+};
+function vn(e) {
+  const t = J();
+  for (let n = 0, i = e.length; n < i; ++n)
+    xe(t, e[n]);
+  return t;
+}
+function Pe(e, t, n) {
+  const i = Math.min.apply(null, e), s = Math.min.apply(null, t), r = Math.max.apply(null, e), o = Math.max.apply(null, t);
+  return Q(i, s, r, o, n);
+}
+function zn(e, t, n) {
+  return n ? (n[0] = e[0] - t, n[1] = e[1] - t, n[2] = e[2] + t, n[3] = e[3] + t, n) : [
+    e[0] - t,
+    e[1] - t,
+    e[2] + t,
+    e[3] + t
+  ];
+}
+function Un(e, t) {
+  return t ? (t[0] = e[0], t[1] = e[1], t[2] = e[2], t[3] = e[3], t) : e.slice();
+}
+function Yt(e, t, n) {
+  let i, s;
+  return t < e[0] ? i = e[0] - t : e[2] < t ? i = t - e[2] : i = 0, n < e[1] ? s = e[1] - n : e[3] < n ? s = n - e[3] : s = 0, i * i + s * s;
+}
+function Yn(e, t) {
+  return Vt(e, t[0], t[1]);
+}
+function Ne(e, t) {
+  return e[0] <= t[0] && t[2] <= e[2] && e[1] <= t[1] && t[3] <= e[3];
+}
+function Vt(e, t, n) {
+  return e[0] <= t && t <= e[2] && e[1] <= n && n <= e[3];
+}
+function pt(e, t) {
+  const n = e[0], i = e[1], s = e[2], r = e[3], o = t[0], u = t[1];
+  let a = C.UNKNOWN;
+  return o < n ? a = a | C.LEFT : o > s && (a = a | C.RIGHT), u < i ? a = a | C.BELOW : u > r && (a = a | C.ABOVE), a === C.UNKNOWN && (a = C.INTERSECTING), a;
+}
+function J() {
+  return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+}
+function Q(e, t, n, i, s) {
+  return s ? (s[0] = e, s[1] = t, s[2] = n, s[3] = i, s) : [e, t, n, i];
+}
+function tt(e) {
+  return Q(1 / 0, 1 / 0, -1 / 0, -1 / 0, e);
+}
+function Oe(e, t) {
+  const n = e[0], i = e[1];
+  return Q(n, i, n, i, t);
+}
+function Fe(e, t, n, i, s) {
+  const r = tt(s);
+  return Dt(r, e, t, n, i);
+}
+function Vn(e, t) {
+  return e[0] == t[0] && e[2] == t[2] && e[1] == t[1] && e[3] == t[3];
+}
+function Dn(e, t) {
+  return t[0] < e[0] && (e[0] = t[0]), t[2] > e[2] && (e[2] = t[2]), t[1] < e[1] && (e[1] = t[1]), t[3] > e[3] && (e[3] = t[3]), e;
+}
+function xe(e, t) {
+  t[0] < e[0] && (e[0] = t[0]), t[0] > e[2] && (e[2] = t[0]), t[1] < e[1] && (e[1] = t[1]), t[1] > e[3] && (e[3] = t[1]);
+}
+function Dt(e, t, n, i, s) {
+  for (; n < i; n += s)
+    be(e, t[n], t[n + 1]);
+  return e;
+}
+function be(e, t, n) {
+  e[0] = Math.min(e[0], t), e[1] = Math.min(e[1], n), e[2] = Math.max(e[2], t), e[3] = Math.max(e[3], n);
+}
+function Ze(e, t) {
+  let n;
+  return n = t(Wt(e)), n || (n = t(Kt(e)), n) || (n = t(Bt(e)), n) || (n = t(kt(e)), n) ? n : !1;
+}
+function Wn(e) {
+  let t = 0;
+  return et(e) || (t = A(e) * X(e)), t;
+}
+function Wt(e) {
+  return [e[0], e[1]];
+}
+function Kt(e) {
+  return [e[2], e[1]];
+}
+function j(e) {
+  return [(e[0] + e[2]) / 2, (e[1] + e[3]) / 2];
+}
+function Kn(e, t) {
+  let n;
+  return t === "bottom-left" ? n = Wt(e) : t === "bottom-right" ? n = Kt(e) : t === "top-left" ? n = kt(e) : t === "top-right" ? n = Bt(e) : S(!1, 13), n;
+}
+function Xe(e, t, n, i, s) {
+  const [r, o, u, a, c, l, h, g] = Ge(
+    e,
+    t,
+    n,
+    i
+  );
+  return Q(
+    Math.min(r, u, c, h),
+    Math.min(o, a, l, g),
+    Math.max(r, u, c, h),
+    Math.max(o, a, l, g),
+    s
+  );
+}
+function Ge(e, t, n, i) {
+  const s = t * i[0] / 2, r = t * i[1] / 2, o = Math.cos(n), u = Math.sin(n), a = s * o, c = s * u, l = r * o, h = r * u, g = e[0], f = e[1];
+  return [
+    g - a + h,
+    f - c - l,
+    g - a - h,
+    f - c + l,
+    g + a - h,
+    f + c + l,
+    g + a + h,
+    f + c - l,
+    g - a + h,
+    f - c - l
+  ];
+}
+function X(e) {
+  return e[3] - e[1];
+}
+function kn(e, t, n) {
+  const i = n || J();
+  return ct(e, t) ? (e[0] > t[0] ? i[0] = e[0] : i[0] = t[0], e[1] > t[1] ? i[1] = e[1] : i[1] = t[1], e[2] < t[2] ? i[2] = e[2] : i[2] = t[2], e[3] < t[3] ? i[3] = e[3] : i[3] = t[3]) : tt(i), i;
+}
+function Bn(e) {
+  return [e[2] - e[0], e[3] - e[1]];
+}
+function kt(e) {
+  return [e[0], e[3]];
+}
+function Bt(e) {
+  return [e[2], e[3]];
+}
+function A(e) {
+  return e[2] - e[0];
+}
+function ct(e, t) {
+  return e[0] <= t[2] && e[2] >= t[0] && e[1] <= t[3] && e[3] >= t[1];
+}
+function et(e) {
+  return e[2] < e[0] || e[3] < e[1];
+}
+function Le(e, t) {
+  return t ? (t[0] = e[0], t[1] = e[1], t[2] = e[2], t[3] = e[3], t) : e;
+}
+function je(e, t, n) {
+  let i = !1;
+  const s = pt(e, t), r = pt(e, n);
+  if (s === C.INTERSECTING || r === C.INTERSECTING)
+    i = !0;
+  else {
+    const o = e[0], u = e[1], a = e[2], c = e[3], l = t[0], h = t[1], g = n[0], f = n[1], d = (f - h) / (g - l);
+    let _, R;
+    r & C.ABOVE && !(s & C.ABOVE) && (_ = g - (f - c) / d, i = _ >= o && _ <= a), !i && r & C.RIGHT && !(s & C.RIGHT) && (R = f - (g - a) * d, i = R >= u && R <= c), !i && r & C.BELOW && !(s & C.BELOW) && (_ = g - (f - u) / d, i = _ >= o && _ <= a), !i && r & C.LEFT && !(s & C.LEFT) && (R = f - (g - o) * d, i = R >= u && R <= c);
+  }
+  return i;
+}
+function ve(e, t, n, i) {
+  if (et(e))
+    return tt(n);
+  let s = [];
+  s = [
+    e[0],
+    e[1],
+    e[2],
+    e[1],
+    e[2],
+    e[3],
+    e[0],
+    e[3]
+  ], t(s, s, 2);
+  const r = [], o = [];
+  for (let u = 0, a = s.length; u < a; u += 2)
+    r.push(s[u]), o.push(s[u + 1]);
+  return Pe(r, o, n);
+}
+function ze(e, t) {
+  const n = t.getExtent(), i = j(e);
+  if (t.canWrapX() && (i[0] < n[0] || i[0] >= n[2])) {
+    const s = A(n), o = Math.floor(
+      (i[0] - n[0]) / s
+    ) * s;
+    e[0] -= o, e[2] -= o;
+  }
+  return e;
+}
+function qn(e, t) {
+  if (t.canWrapX()) {
+    const n = t.getExtent();
+    if (!isFinite(e[0]) || !isFinite(e[2]))
+      return [[n[0], e[1], n[2], e[3]]];
+    ze(e, t);
+    const i = A(n);
+    if (A(e) > i)
+      return [[n[0], e[1], n[2], e[3]]];
+    if (e[0] < n[0])
+      return [
+        [e[0] + i, e[1], n[2], e[3]],
+        [n[0], e[1], e[2], e[3]]
+      ];
+    if (e[2] > n[2])
+      return [
+        [e[0], e[1], n[2], e[3]],
+        [n[0], e[1], e[2] - i, e[3]]
+      ];
+  }
+  return [e];
+}
+const qt = {
+  // 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 $t {
+  /**
+   * @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_ || qt[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 U = 6378137, b = Math.PI * U, Ue = [-b, -b, b, b], Ye = [-180, -85, 180, 85], V = U * Math.log(Math.tan(Math.PI / 2));
+class F extends $t {
+  /**
+   * @param {string} code Code.
+   */
+  constructor(t) {
+    super({
+      code: t,
+      units: "m",
+      extent: Ue,
+      global: !0,
+      worldExtent: Ye,
+      getPointResolution: function(n, i) {
+        return n / Math.cosh(i[1] / U);
+      }
+    });
+  }
+}
+const At = [
+  new F("EPSG:3857"),
+  new F("EPSG:102100"),
+  new F("EPSG:102113"),
+  new F("EPSG:900913"),
+  new F("http://www.opengis.net/def/crs/EPSG/0/3857"),
+  new F("http://www.opengis.net/gml/srs/epsg.xml#3857")
+];
+function Ve(e, t, n) {
+  const i = e.length;
+  n = n > 1 ? n : 2, t === void 0 && (n > 2 ? t = e.slice() : t = new Array(i));
+  for (let s = 0; s < i; s += n) {
+    t[s] = b * e[s] / 180;
+    let r = U * Math.log(Math.tan(Math.PI * (+e[s + 1] + 90) / 360));
+    r > V ? r = V : r < -V && (r = -V), t[s + 1] = r;
+  }
+  return t;
+}
+function De(e, t, n) {
+  const i = e.length;
+  n = n > 1 ? n : 2, t === void 0 && (n > 2 ? t = e.slice() : t = new Array(i));
+  for (let s = 0; s < i; s += n)
+    t[s] = 180 * e[s] / b, t[s + 1] = 360 * Math.atan(Math.exp(e[s + 1] / U)) / Math.PI - 90;
+  return t;
+}
+const We = 6378137, wt = [-180, -90, 180, 90], Ke = Math.PI * We / 180;
+class N extends $t {
+  /**
+   * @param {string} code Code.
+   * @param {string} [axisOrientation] Axis orientation.
+   */
+  constructor(t, n) {
+    super({
+      code: t,
+      units: "degrees",
+      extent: wt,
+      axisOrientation: n,
+      global: !0,
+      metersPerUnit: Ke,
+      worldExtent: wt
+    });
+  }
+}
+const Tt = [
+  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 at = {};
+function ke(e) {
+  return at[e] || at[e.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\w+)$/, "EPSG:$3")] || null;
+}
+function Be(e, t) {
+  at[e] = t;
+}
+let Z = {};
+function B(e, t, n) {
+  const i = e.getCode(), s = t.getCode();
+  i in Z || (Z[i] = {}), Z[i][s] = n;
+}
+function qe(e, t) {
+  let n;
+  return e in Z && t in Z[e] && (n = Z[e][t]), n;
+}
+function $e(e, t) {
+  return e[0] += +t[0], e[1] += +t[1], e;
+}
+function $n(e, t) {
+  const n = t.getRadius(), i = t.getCenter(), s = i[0], r = i[1], o = e[0], u = e[1];
+  let a = o - s;
+  const c = u - r;
+  a === 0 && c === 0 && (a = 1);
+  const l = Math.sqrt(a * a + c * c), h = s + n * a / l, g = r + n * c / l;
+  return [h, g];
+}
+function He(e, t) {
+  const n = e[0], i = e[1], s = t[0], r = t[1], o = s[0], u = s[1], a = r[0], c = r[1], l = a - o, h = c - u, g = l === 0 && h === 0 ? 0 : (l * (n - o) + h * (i - u)) / (l * l + h * h || 0);
+  let f, d;
+  return g <= 0 ? (f = o, d = u) : g >= 1 ? (f = a, d = c) : (f = o + g * l, d = u + g * h), [f, d];
+}
+function q(e, t) {
+  let n = !0;
+  for (let i = e.length - 1; i >= 0; --i)
+    if (e[i] != t[i]) {
+      n = !1;
+      break;
+    }
+  return n;
+}
+function Je(e, t) {
+  const n = Math.cos(t), i = Math.sin(t), s = e[0] * n - e[1] * i, r = e[1] * n + e[0] * i;
+  return e[0] = s, e[1] = r, e;
+}
+function Hn(e, t) {
+  return e[0] *= t, e[1] *= t, e;
+}
+function Ht(e, t) {
+  const n = e[0] - t[0], i = e[1] - t[1];
+  return n * n + i * i;
+}
+function Jn(e, t) {
+  return Math.sqrt(Ht(e, t));
+}
+function Qn(e, t) {
+  return Ht(e, He(e, t));
+}
+function ti(e, t) {
+  if (t.canWrapX()) {
+    const n = A(t.getExtent()), i = Qe(e, t, n);
+    i && (e[0] -= i * n);
+  }
+  return e;
+}
+function Qe(e, t, n) {
+  const i = t.getExtent();
+  let s = 0;
+  return t.canWrapX() && (e[0] < i[0] || e[0] > i[2]) && (n = n || A(i), s = Math.floor(
+    (e[0] - i[0]) / n
+  )), s;
+}
+const tn = 63710088e-1;
+function Pt(e, t, n) {
+  n = n || tn;
+  const i = K(e[1]), s = K(t[1]), r = (s - i) / 2, o = K(t[0] - e[0]) / 2, u = Math.sin(r) * Math.sin(r) + Math.sin(o) * Math.sin(o) * Math.cos(i) * Math.cos(s);
+  return 2 * n * Math.atan2(Math.sqrt(u), Math.sqrt(1 - u));
+}
+function en(...e) {
+  console.warn(...e);
+}
+let ut = !0;
+function Jt(e) {
+  ut = !1;
+}
+function ht(e, t) {
+  if (t !== void 0) {
+    for (let n = 0, i = e.length; n < i; ++n)
+      t[n] = e[n];
+    t = t;
+  } else
+    t = e.slice();
+  return t;
+}
+function Qt(e, t) {
+  if (t !== void 0 && e !== t) {
+    for (let n = 0, i = e.length; n < i; ++n)
+      t[n] = e[n];
+    e = t;
+  }
+  return e;
+}
+function nn(e) {
+  Be(e.getCode(), e), B(e, e, ht);
+}
+function sn(e) {
+  e.forEach(nn);
+}
+function P(e) {
+  return typeof e == "string" ? ke(
+    /** @type {string} */
+    e
+  ) : (
+    /** @type {Projection} */
+    e || null
+  );
+}
+function ei(e, t, n, i) {
+  e = P(e);
+  let s;
+  const r = e.getPointResolutionFunc();
+  if (r)
+    s = r(t, n);
+  else {
+    const o = e.getUnits();
+    if (o == "degrees" && !i || i == "degrees")
+      s = t;
+    else {
+      const u = ft(
+        e,
+        P("EPSG:4326")
+      );
+      if (u === Qt && o !== "degrees")
+        s = t * e.getMetersPerUnit();
+      else {
+        let c = [
+          n[0] - t / 2,
+          n[1],
+          n[0] + t / 2,
+          n[1],
+          n[0],
+          n[1] - t / 2,
+          n[0],
+          n[1] + t / 2
+        ];
+        c = u(c, c, 2);
+        const l = Pt(c.slice(0, 2), c.slice(2, 4)), h = Pt(c.slice(4, 6), c.slice(6, 8));
+        s = (l + h) / 2;
+      }
+      const a = e.getMetersPerUnit();
+      a !== void 0 && (s /= a);
+    }
+  }
+  return s;
+}
+function Nt(e) {
+  sn(e), e.forEach(function(t) {
+    e.forEach(function(n) {
+      t !== n && B(t, n, ht);
+    });
+  });
+}
+function rn(e, t, n, i) {
+  e.forEach(function(s) {
+    t.forEach(function(r) {
+      B(s, r, n), B(r, s, i);
+    });
+  });
+}
+function gt(e, t) {
+  return e ? typeof e == "string" ? P(e) : (
+    /** @type {Projection} */
+    e
+  ) : P(t);
+}
+function ni(e, t) {
+  return Jt(), te(
+    e,
+    "EPSG:4326",
+    "EPSG:3857"
+  );
+}
+function ii(e, t) {
+  const n = te(
+    e,
+    "EPSG:3857",
+    "EPSG:4326"
+  ), i = n[0];
+  return (i < -180 || i > 180) && (n[0] = k(i + 180, 360) - 180), n;
+}
+function si(e, t) {
+  if (e === t)
+    return !0;
+  const n = e.getUnits() === t.getUnits();
+  return (e.getCode() === t.getCode() || ft(e, t) === ht) && n;
+}
+function ft(e, t) {
+  const n = e.getCode(), i = t.getCode();
+  let s = qe(n, i);
+  return s || (s = Qt), s;
+}
+function $(e, t) {
+  const n = P(e), i = P(t);
+  return ft(n, i);
+}
+function te(e, t, n) {
+  return $(t, n)(e, void 0, e.length);
+}
+function ri(e, t, n, i) {
+  const s = $(t, n);
+  return ve(e, s, void 0);
+}
+function Ot(e, t) {
+  return e;
+}
+function w(e, t) {
+  return ut && !q(e, [0, 0]) && e[0] >= -180 && e[0] <= 180 && e[1] >= -90 && e[1] <= 90 && (ut = !1, en(
+    "Call useGeographic() from ol/proj once to work with [longitude, latitude] coordinates."
+  )), e;
+}
+function on(e, t) {
+  return e;
+}
+function D(e, t) {
+  return e;
+}
+function an() {
+  Nt(At), Nt(Tt), rn(
+    Tt,
+    At,
+    Ve,
+    De
+  );
+}
+an();
+const dt = new Array(6);
+function un() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function oi(e) {
+  return Y(e, 1, 0, 0, 1, 0, 0);
+}
+function _t(e, t) {
+  const n = e[0], i = e[1], s = e[2], r = e[3], o = e[4], u = e[5], a = t[0], c = t[1], l = t[2], h = t[3], g = t[4], f = t[5];
+  return e[0] = n * a + s * c, e[1] = i * a + r * c, e[2] = n * l + s * h, e[3] = i * l + r * h, e[4] = n * g + s * f + o, e[5] = i * g + r * f + u, e;
+}
+function Y(e, t, n, i, s, r, o) {
+  return e[0] = t, e[1] = n, e[2] = i, e[3] = s, e[4] = r, e[5] = o, e;
+}
+function ai(e, t) {
+  return e[0] = t[0], e[1] = t[1], e[2] = t[2], e[3] = t[3], e[4] = t[4], e[5] = t[5], e;
+}
+function ui(e, t) {
+  const n = t[0], i = t[1];
+  return t[0] = e[0] * n + e[2] * i + e[4], t[1] = e[1] * n + e[3] * i + e[5], t;
+}
+function li(e, t) {
+  const n = Math.cos(t), i = Math.sin(t);
+  return _t(e, Y(dt, n, i, -i, n, 0, 0));
+}
+function ci(e, t, n) {
+  return _t(e, Y(dt, t, 0, 0, n, 0, 0));
+}
+function hi(e, t, n) {
+  return Y(e, t, 0, 0, n, 0, 0);
+}
+function gi(e, t, n) {
+  return _t(e, Y(dt, 1, 0, 0, 1, t, n));
+}
+function ln(e, t, n, i, s, r, o, u) {
+  const a = Math.sin(r), c = Math.cos(r);
+  return e[0] = i * c, e[1] = s * a, e[2] = -i * a, e[3] = s * c, e[4] = o * i * c - u * i * a + t, e[5] = o * s * a + u * s * c + n, e;
+}
+function fi(e, t) {
+  const n = cn(t);
+  S(n !== 0, 32);
+  const i = t[0], s = t[1], r = t[2], o = t[3], u = t[4], a = t[5];
+  return e[0] = o / n, e[1] = -s / n, e[2] = -r / n, e[3] = i / n, e[4] = (r * a - o * u) / n, e[5] = -(i * a - s * u) / n, e;
+}
+function cn(e) {
+  return e[0] * e[3] - e[1] * e[2];
+}
+let Ft;
+function di(e) {
+  const t = "matrix(" + e.join(", ") + ")";
+  if (ye)
+    return t;
+  const n = Ft || (Ft = document.createElement("div"));
+  return n.style.transform = t, n.style.transform;
+}
+function ee(e, t, n, i, s, r) {
+  r = r || [];
+  let o = 0;
+  for (let u = t; u < n; u += i) {
+    const a = e[u], c = e[u + 1];
+    r[o++] = s[0] * a + s[2] * c + s[4], r[o++] = s[1] * a + s[3] * c + s[5];
+  }
+  return r && r.length != o && (r.length = o), r;
+}
+function hn(e, t, n, i, s, r, o) {
+  o = o || [];
+  const u = Math.cos(s), a = Math.sin(s), c = r[0], l = r[1];
+  let h = 0;
+  for (let g = t; g < n; g += i) {
+    const f = e[g] - c, d = e[g + 1] - l;
+    o[h++] = c + f * u - d * a, o[h++] = l + f * a + d * u;
+    for (let _ = g + 2; _ < g + i; ++_)
+      o[h++] = e[_];
+  }
+  return o && o.length != h && (o.length = h), o;
+}
+function gn(e, t, n, i, s, r, o, u) {
+  u = u || [];
+  const a = o[0], c = o[1];
+  let l = 0;
+  for (let h = t; h < n; h += i) {
+    const g = e[h] - a, f = e[h + 1] - c;
+    u[l++] = a + s * g, u[l++] = c + r * f;
+    for (let d = h + 2; d < h + i; ++d)
+      u[l++] = e[d];
+  }
+  return u && u.length != l && (u.length = l), u;
+}
+function fn(e, t, n, i, s, r, o) {
+  o = o || [];
+  let u = 0;
+  for (let a = t; a < n; a += i) {
+    o[u++] = e[a] + s, o[u++] = e[a + 1] + r;
+    for (let c = a + 2; c < a + i; ++c)
+      o[u++] = e[c];
+  }
+  return o && o.length != u && (o.length = u), o;
+}
+const xt = un();
+class dn extends H {
+  constructor() {
+    super(), this.extent_ = J(), this.extentRevision_ = -1, this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = 0, this.simplifyTransformedInternal = Me(function(t, n, i) {
+      if (!i)
+        return this.getSimplifiedGeometry(n);
+      const s = this.clone();
+      return s.applyTransform(i), s.getSimplifiedGeometry(n);
+    });
+  }
+  /**
+   * 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, n) {
+    return this.simplifyTransformedInternal(
+      this.getRevision(),
+      t,
+      n
+    );
+  }
+  /**
+   * 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, n, i, s) {
+    return E();
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, n) {
+    const i = this.getClosestPoint([t, n]);
+    return i[0] === t && i[1] === n;
+  }
+  /**
+   * 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, n) {
+    return n = n || [NaN, NaN], this.closestPointXY(t[0], t[1], n, 1 / 0), n;
+  }
+  /**
+   * 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 n = this.computeExtent(this.extent_);
+      (isNaN(n[0]) || isNaN(n[1])) && tt(n), this.extentRevision_ = this.getRevision();
+    }
+    return Le(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, n) {
+    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, n, 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, n) {
+    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, n) {
+    const i = P(t), s = i.getUnits() == "tile-pixels" ? function(r, o, u) {
+      const a = i.getExtent(), c = i.getWorldExtent(), l = X(c) / X(a);
+      return ln(
+        xt,
+        c[0],
+        c[3],
+        l,
+        -l,
+        0,
+        0,
+        0
+      ), ee(
+        r,
+        0,
+        r.length,
+        u,
+        xt,
+        o
+      ), $(i, n)(
+        r,
+        o,
+        u
+      );
+    } : $(i, n);
+    return this.applyTransform(s), this;
+  }
+}
+class Rt extends dn {
+  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 Fe(
+      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 n = this.getSimplifiedGeometryInternal(t);
+    return n.getFlatCoordinates().length < this.flatCoordinates.length ? n : (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, n) {
+    this.stride = bt(t), this.layout = t, this.flatCoordinates = n;
+  }
+  /**
+   * @abstract
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  setCoordinates(t, n) {
+    E();
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout|undefined} layout Layout.
+   * @param {Array<*>} coordinates Coordinates.
+   * @param {number} nesting Nesting.
+   * @protected
+   */
+  setLayout(t, n, i) {
+    let s;
+    if (t)
+      s = bt(t);
+    else {
+      for (let r = 0; r < i; ++r) {
+        if (n.length === 0) {
+          this.layout = "XY", this.stride = 2;
+          return;
+        }
+        n = /** @type {Array} */
+        n[0];
+      }
+      s = n.length, t = _n(s);
+    }
+    this.layout = t, this.stride = s;
+  }
+  /**
+   * 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, n) {
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const s = this.getStride();
+      hn(
+        i,
+        0,
+        i.length,
+        s,
+        t,
+        n,
+        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, n, i) {
+    n === void 0 && (n = t), i || (i = j(this.getExtent()));
+    const s = this.getFlatCoordinates();
+    if (s) {
+      const r = this.getStride();
+      gn(
+        s,
+        0,
+        s.length,
+        r,
+        t,
+        n,
+        i,
+        s
+      ), 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, n) {
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const s = this.getStride();
+      fn(
+        i,
+        0,
+        i.length,
+        s,
+        t,
+        n,
+        i
+      ), this.changed();
+    }
+  }
+}
+function _n(e) {
+  let t;
+  return e == 2 ? t = "XY" : e == 3 ? t = "XYZ" : e == 4 && (t = "XYZM"), /** @type {import("./Geometry.js").GeometryLayout} */
+  t;
+}
+function bt(e) {
+  let t;
+  return e == "XY" ? t = 2 : e == "XYZ" || e == "XYM" ? t = 3 : e == "XYZM" && (t = 4), /** @type {number} */
+  t;
+}
+function _i(e, t, n) {
+  const i = e.getFlatCoordinates();
+  if (!i)
+    return null;
+  const s = e.getStride();
+  return ee(
+    i,
+    0,
+    i.length,
+    s,
+    t,
+    n
+  );
+}
+function Zt(e, t, n, i, s, r, o) {
+  const u = e[t], a = e[t + 1], c = e[n] - u, l = e[n + 1] - a;
+  let h;
+  if (c === 0 && l === 0)
+    h = t;
+  else {
+    const g = ((s - u) * c + (r - a) * l) / (c * c + l * l);
+    if (g > 1)
+      h = n;
+    else if (g > 0) {
+      for (let f = 0; f < i; ++f)
+        o[f] = Ce(
+          e[t + f],
+          e[n + f],
+          g
+        );
+      o.length = i;
+      return;
+    } else
+      h = t;
+  }
+  for (let g = 0; g < i; ++g)
+    o[g] = e[h + g];
+  o.length = i;
+}
+function ne(e, t, n, i, s) {
+  let r = e[t], o = e[t + 1];
+  for (t += i; t < n; t += i) {
+    const u = e[t], a = e[t + 1], c = L(r, o, u, a);
+    c > s && (s = c), r = u, o = a;
+  }
+  return s;
+}
+function ie(e, t, n, i, s) {
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r];
+    s = ne(e, t, u, i, s), t = u;
+  }
+  return s;
+}
+function Ri(e, t, n, i, s) {
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r];
+    s = ie(e, t, u, i, s), t = u[u.length - 1];
+  }
+  return s;
+}
+function se(e, t, n, i, s, r, o, u, a, c, l) {
+  if (t == n)
+    return c;
+  let h, g;
+  if (s === 0) {
+    if (g = L(
+      o,
+      u,
+      e[t],
+      e[t + 1]
+    ), g < c) {
+      for (h = 0; h < i; ++h)
+        a[h] = e[t + h];
+      return a.length = i, g;
+    }
+    return c;
+  }
+  l = l || [NaN, NaN];
+  let f = t + i;
+  for (; f < n; )
+    if (Zt(
+      e,
+      f - i,
+      f,
+      i,
+      o,
+      u,
+      l
+    ), g = L(o, u, l[0], l[1]), g < c) {
+      for (c = g, h = 0; h < i; ++h)
+        a[h] = l[h];
+      a.length = i, f += i;
+    } else
+      f += i * Math.max(
+        (Math.sqrt(g) - Math.sqrt(c)) / s | 0,
+        1
+      );
+  if (r && (Zt(
+    e,
+    n - i,
+    t,
+    i,
+    o,
+    u,
+    l
+  ), g = L(o, u, l[0], l[1]), g < c)) {
+    for (c = g, h = 0; h < i; ++h)
+      a[h] = l[h];
+    a.length = i;
+  }
+  return c;
+}
+function re(e, t, n, i, s, r, o, u, a, c, l) {
+  l = l || [NaN, NaN];
+  for (let h = 0, g = n.length; h < g; ++h) {
+    const f = n[h];
+    c = se(
+      e,
+      t,
+      f,
+      i,
+      s,
+      r,
+      o,
+      u,
+      a,
+      c,
+      l
+    ), t = f;
+  }
+  return c;
+}
+function mi(e, t, n, i, s, r, o, u, a, c, l) {
+  l = l || [NaN, NaN];
+  for (let h = 0, g = n.length; h < g; ++h) {
+    const f = n[h];
+    c = re(
+      e,
+      t,
+      f,
+      i,
+      s,
+      r,
+      o,
+      u,
+      a,
+      c,
+      l
+    ), t = f[f.length - 1];
+  }
+  return c;
+}
+function Rn(e, t, n, i) {
+  for (let s = 0, r = n.length; s < r; ++s)
+    e[t++] = n[s];
+  return t;
+}
+function oe(e, t, n, i) {
+  for (let s = 0, r = n.length; s < r; ++s) {
+    const o = n[s];
+    for (let u = 0; u < i; ++u)
+      e[t++] = o[u];
+  }
+  return t;
+}
+function ae(e, t, n, i, s) {
+  s = s || [];
+  let r = 0;
+  for (let o = 0, u = n.length; o < u; ++o) {
+    const a = oe(
+      e,
+      t,
+      n[o],
+      i
+    );
+    s[r++] = a, t = a;
+  }
+  return s.length = r, s;
+}
+function yi(e, t, n, i, s) {
+  s = s || [];
+  let r = 0;
+  for (let o = 0, u = n.length; o < u; ++o) {
+    const a = ae(
+      e,
+      t,
+      n[o],
+      i,
+      s[r]
+    );
+    a.length === 0 && (a[0] = t), s[r++] = a, t = a[a.length - 1];
+  }
+  return s.length = r, s;
+}
+function ue(e, t, n, i, s, r, o) {
+  const u = (n - t) / i;
+  if (u < 3) {
+    for (; t < n; t += i)
+      r[o++] = e[t], r[o++] = e[t + 1];
+    return o;
+  }
+  const a = new Array(u);
+  a[0] = 1, a[u - 1] = 1;
+  const c = [t, n - i];
+  let l = 0;
+  for (; c.length > 0; ) {
+    const h = c.pop(), g = c.pop();
+    let f = 0;
+    const d = e[g], _ = e[g + 1], R = e[h], M = e[h + 1];
+    for (let y = g + i; y < h; y += i) {
+      const nt = e[y], G = e[y + 1], It = Ee(nt, G, d, _, R, M);
+      It > f && (l = y, f = It);
+    }
+    f > s && (a[(l - t) / i] = 1, g + i < l && c.push(g, l), l + i < h && c.push(l, h));
+  }
+  for (let h = 0; h < u; ++h)
+    a[h] && (r[o++] = e[t + h * i], r[o++] = e[t + h * i + 1]);
+  return o;
+}
+function Mi(e, t, n, i, s, r, o, u) {
+  for (let a = 0, c = n.length; a < c; ++a) {
+    const l = n[a];
+    o = ue(
+      e,
+      t,
+      l,
+      i,
+      s,
+      r,
+      o
+    ), u.push(o), t = l;
+  }
+  return o;
+}
+function x(e, t) {
+  return t * Math.round(e / t);
+}
+function mn(e, t, n, i, s, r, o) {
+  if (t == n)
+    return o;
+  let u = x(e[t], s), a = x(e[t + 1], s);
+  t += i, r[o++] = u, r[o++] = a;
+  let c, l;
+  do
+    if (c = x(e[t], s), l = x(e[t + 1], s), t += i, t == n)
+      return r[o++] = c, r[o++] = l, o;
+  while (c == u && l == a);
+  for (; t < n; ) {
+    const h = x(e[t], s), g = x(e[t + 1], s);
+    if (t += i, h == c && g == l)
+      continue;
+    const f = c - u, d = l - a, _ = h - u, R = g - a;
+    if (f * R == d * _ && (f < 0 && _ < f || f == _ || f > 0 && _ > f) && (d < 0 && R < d || d == R || d > 0 && R > d)) {
+      c = h, l = g;
+      continue;
+    }
+    r[o++] = c, r[o++] = l, u = c, a = l, c = h, l = g;
+  }
+  return r[o++] = c, r[o++] = l, o;
+}
+function le(e, t, n, i, s, r, o, u) {
+  for (let a = 0, c = n.length; a < c; ++a) {
+    const l = n[a];
+    o = mn(
+      e,
+      t,
+      l,
+      i,
+      s,
+      r,
+      o
+    ), u.push(o), t = l;
+  }
+  return o;
+}
+function Ci(e, t, n, i, s, r, o, u) {
+  for (let a = 0, c = n.length; a < c; ++a) {
+    const l = n[a], h = [];
+    o = le(
+      e,
+      t,
+      l,
+      i,
+      s,
+      r,
+      o,
+      h
+    ), u.push(h), t = l[l.length - 1];
+  }
+  return o;
+}
+function yn(e, t, n, i, s) {
+  let r;
+  for (t += i; t < n; t += i)
+    if (r = s(
+      e.slice(t - i, t),
+      e.slice(t, t + i)
+    ), r)
+      return r;
+  return !1;
+}
+function ce(e, t, n, i, s) {
+  s = s !== void 0 ? s : [];
+  let r = 0;
+  for (let o = t; o < n; o += i)
+    s[r++] = e.slice(o, o + i);
+  return s.length = r, s;
+}
+function he(e, t, n, i, s) {
+  s = s !== void 0 ? s : [];
+  let r = 0;
+  for (let o = 0, u = n.length; o < u; ++o) {
+    const a = n[o];
+    s[r++] = ce(
+      e,
+      t,
+      a,
+      i,
+      s[r]
+    ), t = a;
+  }
+  return s.length = r, s;
+}
+function Ei(e, t, n, i, s) {
+  s = s !== void 0 ? s : [];
+  let r = 0;
+  for (let o = 0, u = n.length; o < u; ++o) {
+    const a = n[o];
+    s[r++] = a.length === 1 && a[0] === t ? [] : he(
+      e,
+      t,
+      a,
+      i,
+      s[r]
+    ), t = a[a.length - 1];
+  }
+  return s.length = r, s;
+}
+function Mn(e, t, n, i, s) {
+  return !Ze(
+    s,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+     * @return {boolean} Contains (x, y).
+     */
+    function(o) {
+      return !O(
+        e,
+        t,
+        n,
+        i,
+        o[0],
+        o[1]
+      );
+    }
+  );
+}
+function O(e, t, n, i, s, r) {
+  let o = 0, u = e[n - i], a = e[n - i + 1];
+  for (; t < n; t += i) {
+    const c = e[t], l = e[t + 1];
+    a <= r ? l > r && (c - u) * (r - a) - (s - u) * (l - a) > 0 && o++ : l <= r && (c - u) * (r - a) - (s - u) * (l - a) < 0 && o--, u = c, a = l;
+  }
+  return o !== 0;
+}
+function mt(e, t, n, i, s, r) {
+  if (n.length === 0 || !O(e, t, n[0], i, s, r))
+    return !1;
+  for (let o = 1, u = n.length; o < u; ++o)
+    if (O(e, n[o - 1], n[o], i, s, r))
+      return !1;
+  return !0;
+}
+function Ii(e, t, n, i, s, r) {
+  if (n.length === 0)
+    return !1;
+  for (let o = 0, u = n.length; o < u; ++o) {
+    const a = n[o];
+    if (mt(e, t, a, i, s, r))
+      return !0;
+    t = a[a.length - 1];
+  }
+  return !1;
+}
+function yt(e, t, n, i, s) {
+  const r = Dt(
+    J(),
+    e,
+    t,
+    n,
+    i
+  );
+  return ct(s, r) ? Ne(s, r) || r[0] >= s[0] && r[2] <= s[2] || r[1] >= s[1] && r[3] <= s[3] ? !0 : yn(
+    e,
+    t,
+    n,
+    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 je(s, o, u);
+    }
+  ) : !1;
+}
+function Si(e, t, n, i, s) {
+  for (let r = 0, o = n.length; r < o; ++r) {
+    if (yt(e, t, n[r], i, s))
+      return !0;
+    t = n[r];
+  }
+  return !1;
+}
+function Cn(e, t, n, i, s) {
+  return !!(yt(e, t, n, i, s) || O(
+    e,
+    t,
+    n,
+    i,
+    s[0],
+    s[1]
+  ) || O(
+    e,
+    t,
+    n,
+    i,
+    s[0],
+    s[3]
+  ) || O(
+    e,
+    t,
+    n,
+    i,
+    s[2],
+    s[1]
+  ) || O(
+    e,
+    t,
+    n,
+    i,
+    s[2],
+    s[3]
+  ));
+}
+function ge(e, t, n, i, s) {
+  if (!Cn(e, t, n[0], i, s))
+    return !1;
+  if (n.length === 1)
+    return !0;
+  for (let r = 1, o = n.length; r < o; ++r)
+    if (Mn(
+      e,
+      n[r - 1],
+      n[r],
+      i,
+      s
+    ) && !yt(
+      e,
+      n[r - 1],
+      n[r],
+      i,
+      s
+    ))
+      return !1;
+  return !0;
+}
+function pi(e, t, n, i, s) {
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r];
+    if (ge(e, t, u, i, s))
+      return !0;
+    t = u[u.length - 1];
+  }
+  return !1;
+}
+function fe(e, t, n, i) {
+  let s = 0, r = e[n - i], o = e[n - i + 1];
+  for (; t < n; t += i) {
+    const u = e[t], a = e[t + 1];
+    s += o * u - r * a, r = u, o = a;
+  }
+  return s / 2;
+}
+function de(e, t, n, i) {
+  let s = 0;
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r];
+    s += fe(e, t, u, i), t = u;
+  }
+  return s;
+}
+function Ai(e, t, n, i) {
+  let s = 0;
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r];
+    s += de(e, t, u, i), t = u[u.length - 1];
+  }
+  return s;
+}
+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, n) {
+    super(), this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, n !== void 0 && !Array.isArray(t[0]) ? this.setFlatCoordinates(
+      n,
+      /** @type {Array<number>} */
+      t
+    ) : this.setCoordinates(
+      /** @type {Array<import("../coordinate.js").Coordinate>} */
+      t,
+      n
+    );
+  }
+  /**
+   * 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, n, i, s) {
+    return s < Yt(this.getExtent(), t, n) ? s : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      ne(
+        this.flatCoordinates,
+        0,
+        this.flatCoordinates.length,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), se(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      n,
+      i,
+      s
+    ));
+  }
+  /**
+   * Return the area of the linear ring on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return fe(
+      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 ce(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {LinearRing} Simplified LinearRing.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    const n = [];
+    return n.length = ue(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      n,
+      0
+    ), new v(n, "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, n) {
+    this.setLayout(n, t, 1), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = oe(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+class Mt extends Rt {
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, n) {
+    super(), this.setCoordinates(t, n);
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!Point} Clone.
+   * @api
+   */
+  clone() {
+    const t = new Mt(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, n, i, s) {
+    const r = this.flatCoordinates, o = L(
+      t,
+      n,
+      r[0],
+      r[1]
+    );
+    if (o < s) {
+      const u = this.stride;
+      for (let a = 0; a < u; ++a)
+        i[a] = r[a];
+      return i.length = u, o;
+    }
+    return s;
+  }
+  /**
+   * 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 Oe(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 Vt(t, this.flatCoordinates[0], this.flatCoordinates[1]);
+  }
+  /**
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, n) {
+    this.setLayout(n, t, 0), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = Rn(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+function _e(e, t, n, i, s, r, o) {
+  let u, a, c, l, h, g, f;
+  const d = s[r + 1], _ = [];
+  for (let y = 0, nt = n.length; y < nt; ++y) {
+    const G = n[y];
+    for (l = e[G - i], g = e[G - i + 1], u = t; u < G; u += i)
+      h = e[u], f = e[u + 1], (d <= g && f <= d || g <= d && d <= f) && (c = (d - g) / (f - g) * (h - l) + l, _.push(c)), l = h, g = f;
+  }
+  let R = NaN, M = -1 / 0;
+  for (_.sort(Ie), l = _[0], u = 1, a = _.length; u < a; ++u) {
+    h = _[u];
+    const y = Math.abs(h - l);
+    y > M && (c = (l + h) / 2, mt(e, t, n, i, c, d) && (R = c, M = y)), l = h;
+  }
+  return isNaN(R) && (R = s[r]), o ? (o.push(R, d, M), o) : [R, d, M];
+}
+function wi(e, t, n, i, s) {
+  let r = [];
+  for (let o = 0, u = n.length; o < u; ++o) {
+    const a = n[o];
+    r = _e(
+      e,
+      t,
+      a,
+      i,
+      s,
+      2 * o,
+      r
+    ), t = a[a.length - 1];
+  }
+  return r;
+}
+function En(e, t, n, i) {
+  for (; t < n - i; ) {
+    for (let s = 0; s < i; ++s) {
+      const r = e[t + s];
+      e[t + s] = e[n - i + s], e[n - i + s] = r;
+    }
+    t += i, n -= i;
+  }
+}
+function Re(e, t, n, i) {
+  let s = 0, r = e[n - i], o = e[n - i + 1];
+  for (; t < n; t += i) {
+    const u = e[t], a = e[t + 1];
+    s += (u - r) * (a + o), r = u, o = a;
+  }
+  return s === 0 ? void 0 : s > 0;
+}
+function me(e, t, n, i, s) {
+  s = s !== void 0 ? s : !1;
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r], a = Re(
+      e,
+      t,
+      u,
+      i
+    );
+    if (r === 0) {
+      if (s && a || !s && !a)
+        return !1;
+    } else if (s && !a || !s && a)
+      return !1;
+    t = u;
+  }
+  return !0;
+}
+function Ti(e, t, n, i, s) {
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r];
+    if (!me(e, t, u, i, s))
+      return !1;
+    u.length && (t = u[u.length - 1]);
+  }
+  return !0;
+}
+function lt(e, t, n, i, s) {
+  s = s !== void 0 ? s : !1;
+  for (let r = 0, o = n.length; r < o; ++r) {
+    const u = n[r], a = Re(
+      e,
+      t,
+      u,
+      i
+    );
+    (r === 0 ? s && a || !s && !a : s && !a || !s && a) && En(e, t, u, i), t = u;
+  }
+  return t;
+}
+function Pi(e, t, n, i, s) {
+  for (let r = 0, o = n.length; r < o; ++r)
+    t = lt(
+      e,
+      t,
+      n[r],
+      i,
+      s
+    );
+  return t;
+}
+class z 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, n, i) {
+    super(), this.ends_ = [], this.flatInteriorPointRevision_ = -1, this.flatInteriorPoint_ = null, this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, this.orientedRevision_ = -1, this.orientedFlatCoordinates_ = null, n !== void 0 && i ? (this.setFlatCoordinates(
+      n,
+      /** @type {Array<number>} */
+      t
+    ), this.ends_ = i) : this.setCoordinates(
+      /** @type {Array<Array<import("../coordinate.js").Coordinate>>} */
+      t,
+      n
+    );
+  }
+  /**
+   * Append the passed linear ring to this polygon.
+   * @param {LinearRing} linearRing Linear ring.
+   * @api
+   */
+  appendLinearRing(t) {
+    this.flatCoordinates ? Se(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 z(
+      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, n, i, s) {
+    return s < Yt(this.getExtent(), t, n) ? s : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      ie(
+        this.flatCoordinates,
+        0,
+        this.ends_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), re(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      n,
+      i,
+      s
+    ));
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, n) {
+    return mt(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride,
+      t,
+      n
+    );
+  }
+  /**
+   * Return the area of the polygon on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return de(
+      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 n;
+    return t !== void 0 ? (n = this.getOrientedFlatCoordinates().slice(), lt(n, 0, this.ends_, this.stride, t)) : n = this.flatCoordinates, he(n, 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 = j(this.getExtent());
+      this.flatInteriorPoint_ = _e(
+        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 Mt(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, n = this.flatCoordinates, i = this.ends_, s = [];
+    let r = 0;
+    for (let o = 0, u = i.length; o < u; ++o) {
+      const a = i[o], c = new v(
+        n.slice(r, a),
+        t
+      );
+      s.push(c), r = a;
+    }
+    return s;
+  }
+  /**
+   * @return {Array<number>} Oriented flat coordinates.
+   */
+  getOrientedFlatCoordinates() {
+    if (this.orientedRevision_ != this.getRevision()) {
+      const t = this.flatCoordinates;
+      me(t, 0, this.ends_, this.stride) ? this.orientedFlatCoordinates_ = t : (this.orientedFlatCoordinates_ = t.slice(), this.orientedFlatCoordinates_.length = lt(
+        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 n = [], i = [];
+    return n.length = le(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      Math.sqrt(t),
+      n,
+      0,
+      i
+    ), new z(n, "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 ge(
+      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, n) {
+    this.setLayout(n, t, 2), this.flatCoordinates || (this.flatCoordinates = []);
+    const i = ae(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.ends_
+    );
+    this.flatCoordinates.length = i.length === 0 ? 0 : i[i.length - 1], this.changed();
+  }
+}
+function Xt(e) {
+  if (et(e))
+    throw new Error("Cannot create polygon from empty extent");
+  const t = e[0], n = e[1], i = e[2], s = e[3], r = [
+    t,
+    n,
+    t,
+    s,
+    i,
+    s,
+    i,
+    n,
+    t,
+    n
+  ];
+  return new z(r, "XY", [r.length]);
+}
+function Ni(e, t, n) {
+  t = t || 32;
+  const i = e.getStride(), s = e.getLayout(), r = e.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 h = 2; h < i; h++)
+      u[l + h] = r[h];
+  }
+  const a = [u.length], c = new z(u, s, a);
+  return In(c, r, e.getRadius()), c;
+}
+function In(e, t, n, i) {
+  const s = e.getFlatCoordinates(), r = e.getStride(), o = s.length / r - 1, u = 0;
+  for (let a = 0; a <= o; ++a) {
+    const c = a * r, l = u + k(a, o) * 2 * Math.PI / o;
+    s[c] = t[0] + n * Math.cos(l), s[c + 1] = t[1] + n * Math.sin(l);
+  }
+  e.changed();
+}
+function Sn(e) {
+  if (e !== void 0)
+    return 0;
+}
+function Gt(e) {
+  if (e !== void 0)
+    return e;
+}
+function pn(e) {
+  const t = 2 * Math.PI / e;
+  return (
+    /**
+     * @param {number|undefined} rotation Rotation.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @return {number|undefined} Rotation.
+     */
+    function(n, i) {
+      if (i)
+        return n;
+      if (n !== void 0)
+        return n = Math.floor(n / t + 0.5) * t, n;
+    }
+  );
+}
+function An(e) {
+  return e = e || K(5), /**
+   * @param {number|undefined} rotation Rotation.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Rotation.
+   */
+  function(t, n) {
+    if (n)
+      return t;
+    if (t !== void 0)
+      return Math.abs(t) <= e ? 0 : t;
+  };
+}
+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 wn extends H {
+  /**
+   * @param {Options} options Layer options.
+   */
+  constructor(t) {
+    super(), this.on, this.once, this.un, this.background_ = t.background;
+    const n = Object.assign({}, t);
+    typeof t.properties == "object" && (delete n.properties, Object.assign(n, t.properties)), n[m.OPACITY] = t.opacity !== void 0 ? t.opacity : 1, S(typeof n[m.OPACITY] == "number", 64), n[m.VISIBLE] = t.visible !== void 0 ? t.visible : !0, n[m.Z_INDEX] = t.zIndex, n[m.MAX_RESOLUTION] = t.maxResolution !== void 0 ? t.maxResolution : 1 / 0, n[m.MIN_RESOLUTION] = t.minResolution !== void 0 ? t.minResolution : 0, n[m.MIN_ZOOM] = t.minZoom !== void 0 ? t.minZoom : -1 / 0, n[m.MAX_ZOOM] = t.maxZoom !== void 0 ? t.maxZoom : 1 / 0, this.className_ = n.className !== void 0 ? n.className : "ol-layer", delete n.className, this.setProperties(n), 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 n = this.state_ || /** @type {?} */
+    {
+      layer: this,
+      managed: t === void 0 ? !0 : t
+    }, i = this.getZIndex();
+    return n.opacity = p(Math.round(this.getOpacity() * 100) / 100, 0, 1), n.visible = this.getVisible(), n.extent = this.getExtent(), n.zIndex = i === void 0 && !n.managed ? 1 / 0 : i, n.maxResolution = this.getMaxResolution(), n.minResolution = Math.max(this.getMinResolution(), 0), n.minZoom = this.getMinZoom(), n.maxZoom = this.getMaxZoom(), this.state_ = n, n;
+  }
+  /**
+   * @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) {
+    S(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 Tn = {
+  /**
+   * 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"
+}, T = {
+  ANIMATING: 0,
+  INTERACTING: 1
+}, I = {
+  CENTER: "center",
+  RESOLUTION: "resolution",
+  ROTATION: "rotation"
+}, Oi = 42, Pn = 256;
+function Lt(e, t, n) {
+  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, s, r, o, u) {
+      if (!i)
+        return;
+      if (!s && !t)
+        return i;
+      const a = t ? 0 : r[0] * s, c = t ? 0 : r[1] * s, l = u ? u[0] : 0, h = u ? u[1] : 0;
+      let g = e[0] + a / 2 + l, f = e[2] - a / 2 + l, d = e[1] + c / 2 + h, _ = e[3] - c / 2 + h;
+      g > f && (g = (f + g) / 2, f = g), d > _ && (d = (_ + d) / 2, _ = d);
+      let R = p(i[0], g, f), M = p(i[1], d, _);
+      if (o && n && s) {
+        const y = 30 * s;
+        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] - _) / y);
+      }
+      return [R, M];
+    }
+  );
+}
+function Nn(e) {
+  return e;
+}
+function Ct(e, t, n, i) {
+  const s = A(t) / n[0], r = X(t) / n[1];
+  return i ? Math.min(e, Math.max(s, r)) : Math.min(e, Math.min(s, r));
+}
+function Et(e, t, n) {
+  let i = Math.min(e, t);
+  const s = 50;
+  return i *= Math.log(1 + s * Math.max(0, e / t - 1)) / s + 1, n && (i = Math.max(i, n), i /= Math.log(1 + s * Math.max(0, n / e - 1)) / s + 1), p(i, n / 2, t * 2);
+}
+function On(e, t, n, 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(s, r, o, u) {
+    if (s !== void 0) {
+      const a = e[0], c = e[e.length - 1], l = n ? Ct(
+        a,
+        n,
+        o,
+        i
+      ) : a;
+      if (u)
+        return t ? Et(
+          s,
+          l,
+          c
+        ) : p(s, c, l);
+      const h = Math.min(l, s), g = Math.floor(Ut(e, h, r));
+      return e[g] > l && g < e.length - 1 ? e[g + 1] : e[g];
+    }
+  };
+}
+function Fn(e, t, n, i, s, r) {
+  return i = i !== void 0 ? i : !0, n = n !== void 0 ? n : 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, c) {
+    if (o !== void 0) {
+      const l = s ? Ct(
+        t,
+        s,
+        a,
+        r
+      ) : t;
+      if (c)
+        return i ? Et(
+          o,
+          l,
+          n
+        ) : p(o, n, l);
+      const h = 1e-9, g = Math.ceil(
+        Math.log(t / l) / Math.log(e) - h
+      ), f = -u * (0.5 - h) + 0.5, d = Math.min(l, o), _ = Math.floor(
+        Math.log(t / d) / Math.log(e) + f
+      ), R = Math.max(g, _), M = t / Math.pow(e, R);
+      return p(M, n, l);
+    }
+  };
+}
+function jt(e, t, n, i, s) {
+  return n = n !== void 0 ? n : !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, o, u, a) {
+    if (r !== void 0) {
+      const c = i ? Ct(
+        e,
+        i,
+        u,
+        s
+      ) : e;
+      return !n || !a ? p(r, t, c) : Et(
+        r,
+        c,
+        t
+      );
+    }
+  };
+}
+const rt = 0;
+class vt 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_ = gt(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 && Jt(), t.center && (t.center = w(t.center, this.projection_)), t.extent && (t.extent = D(t.extent, this.projection_)), this.applyOptions_(t);
+  }
+  /**
+   * Set up the view with the given options.
+   * @param {ViewOptions} options View options.
+   */
+  applyOptions_(t) {
+    const n = Object.assign({}, t);
+    for (const u in I)
+      delete n[u];
+    this.setProperties(n, !0);
+    const i = bn(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 s = xn(t), r = i.constraint, o = Zn(t);
+    this.constraints_ = {
+      center: s,
+      resolution: r,
+      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 n = this.padding_;
+    this.padding_ = t;
+    const i = this.getCenterInternal();
+    if (i) {
+      const s = t || [0, 0, 0, 0];
+      n = n || [0, 0, 0, 0];
+      const r = this.getResolution(), o = r / 2 * (s[3] - n[3] + n[1] - s[1]), u = r / 2 * (s[0] - n[0] + n[2] - s[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 n = this.getProperties();
+    return n.resolution !== void 0 ? n.resolution = this.getResolution() : n.zoom = this.getZoom(), n.center = this.getCenterInternal(), n.rotation = this.getRotation(), Object.assign({}, n, 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 n = new Array(arguments.length);
+    for (let i = 0; i < n.length; ++i) {
+      let s = arguments[i];
+      s.center && (s = Object.assign({}, s), s.center = w(
+        s.center,
+        this.getProjection()
+      )), s.anchor && (s = Object.assign({}, s), s.anchor = w(
+        s.anchor,
+        this.getProjection()
+      )), n[i] = s;
+    }
+    this.animateInternal.apply(this, n);
+  }
+  /**
+   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation options.
+   */
+  animateInternal(t) {
+    let n = arguments.length, i;
+    n > 1 && typeof arguments[n - 1] == "function" && (i = arguments[n - 1], --n);
+    let s = 0;
+    for (; s < n && !this.isDef(); ++s) {
+      const l = arguments[s];
+      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 (s === n) {
+      i && W(i, !0);
+      return;
+    }
+    let r = Date.now(), o = this.targetCenter_.slice(), u = this.targetResolution_, a = this.targetRotation_;
+    const c = [];
+    for (; s < n; ++s) {
+      const l = (
+        /** @type {AnimationOptions} */
+        arguments[s]
+      ), h = {
+        start: r,
+        complete: !1,
+        anchor: l.anchor,
+        duration: l.duration !== void 0 ? l.duration : 1e3,
+        easing: l.easing || Te,
+        callback: i
+      };
+      if (l.center && (h.sourceCenter = o, h.targetCenter = l.center.slice(), o = h.targetCenter), l.zoom !== void 0 ? (h.sourceResolution = u, h.targetResolution = this.getResolutionForZoom(l.zoom), u = h.targetResolution) : l.resolution && (h.sourceResolution = u, h.targetResolution = l.resolution, u = h.targetResolution), l.rotation !== void 0) {
+        h.sourceRotation = a;
+        const g = k(l.rotation - a + Math.PI, 2 * Math.PI) - Math.PI;
+        h.targetRotation = a + g, a = h.targetRotation;
+      }
+      Xn(h) ? h.complete = !0 : r += h.duration, c.push(h);
+    }
+    this.animations_.push(c), this.setHint(T.ANIMATING, 1), this.updateAnimations_();
+  }
+  /**
+   * Determine if the view is being animated.
+   * @return {boolean} The view is being animated.
+   * @api
+   */
+  getAnimating() {
+    return this.hints_[T.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_[T.INTERACTING] > 0;
+  }
+  /**
+   * Cancel any ongoing animations.
+   * @api
+   */
+  cancelAnimations() {
+    this.setHint(T.ANIMATING, -this.hints_[T.ANIMATING]);
+    let t;
+    for (let n = 0, i = this.animations_.length; n < i; ++n) {
+      const s = this.animations_[n];
+      if (s[0].callback && W(s[0].callback, !1), !t)
+        for (let r = 0, o = s.length; r < o; ++r) {
+          const u = s[r];
+          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 n = !1;
+    for (let i = this.animations_.length - 1; i >= 0; --i) {
+      const s = this.animations_[i];
+      let r = !0;
+      for (let o = 0, u = s.length; o < u; ++o) {
+        const a = s[o];
+        if (a.complete)
+          continue;
+        const c = t - a.start;
+        let l = a.duration > 0 ? c / a.duration : 1;
+        l >= 1 ? (a.complete = !0, l = 1) : r = !1;
+        const h = a.easing(l);
+        if (a.sourceCenter) {
+          const g = a.sourceCenter[0], f = a.sourceCenter[1], d = a.targetCenter[0], _ = a.targetCenter[1];
+          this.nextCenter_ = a.targetCenter;
+          const R = g + h * (d - g), M = f + h * (_ - f);
+          this.targetCenter_ = [R, M];
+        }
+        if (a.sourceResolution && a.targetResolution) {
+          const g = h === 1 ? a.targetResolution : a.sourceResolution + h * (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 = h === 1 ? k(a.targetRotation + Math.PI, 2 * Math.PI) - Math.PI : a.sourceRotation + h * (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), n = !0, !a.complete)
+          break;
+      }
+      if (r) {
+        this.animations_[i] = null, this.setHint(T.ANIMATING, -1), this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
+        const o = s[0].callback;
+        o && W(o, !0);
+      }
+    }
+    this.animations_ = this.animations_.filter(Boolean), n && 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, n) {
+    let i;
+    const s = this.getCenterInternal();
+    return s !== void 0 && (i = [s[0] - n[0], s[1] - n[1]], Je(i, t - this.getRotation()), $e(i, n)), 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, n) {
+    let i;
+    const s = this.getCenterInternal(), r = this.getResolution();
+    if (s !== void 0 && r !== void 0) {
+      const o = n[0] - t * (n[0] - s[0]) / r, u = n[1] - t * (n[1] - s[1]) / r;
+      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 n = this.viewportSize_;
+    if (t) {
+      const i = n[0], s = n[1];
+      return [
+        Math.abs(i * Math.cos(t)) + Math.abs(s * Math.sin(t)),
+        Math.abs(i * Math.sin(t)) + Math.abs(s * Math.cos(t))
+      ];
+    }
+    return n;
+  }
+  /**
+   * 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 && Ot(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 n = this.calculateExtentInternal(t);
+    return on(n, 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 n = (
+      /** @type {!import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    S(n, 1);
+    const i = (
+      /** @type {!number} */
+      this.getResolution()
+    );
+    S(i !== void 0, 2);
+    const s = (
+      /** @type {!number} */
+      this.getRotation()
+    );
+    return S(s !== void 0, 3), Xe(n, i, s, 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, n) {
+    return this.getResolutionForExtentInternal(
+      D(t, this.getProjection()),
+      n
+    );
+  }
+  /**
+   * 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, n) {
+    n = n || this.getViewportSizeMinusPadding_();
+    const i = A(t) / n[0], s = X(t) / n[1];
+    return Math.max(i, s);
+  }
+  /**
+   * 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 n = this.getConstrainedResolution(this.maxResolution_), i = this.minResolution_, s = Math.log(n / i) / Math.log(t);
+    return (
+      /**
+       * @param {number} value Value.
+       * @return {number} Resolution.
+       */
+      function(r) {
+        return n / Math.pow(t, r * s);
+      }
+    );
+  }
+  /**
+   * 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 n = Math.log(t || 2), i = this.getConstrainedResolution(this.maxResolution_), s = this.minResolution_, r = Math.log(i / s) / n;
+    return (
+      /**
+       * @param {number} resolution Resolution.
+       * @return {number} Value.
+       */
+      function(o) {
+        return Math.log(i / o) / n / r;
+      }
+    );
+  }
+  /**
+   * 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 n = this.getViewportSize_(t);
+    const i = this.padding_;
+    return i && (n = [
+      n[0] - i[1] - i[3],
+      n[1] - i[0] - i[2]
+    ]), n;
+  }
+  /**
+   * @return {State} View state.
+   */
+  getState() {
+    const t = this.getProjection(), n = this.getResolution(), i = this.getRotation();
+    let s = (
+      /** @type {import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    const r = this.padding_;
+    if (r) {
+      const o = this.getViewportSizeMinusPadding_();
+      s = ot(
+        s,
+        this.getViewportSize_(),
+        [o[0] / 2 + r[3], o[1] / 2 + r[0]],
+        n,
+        i
+      );
+    }
+    return {
+      center: s.slice(0),
+      projection: t !== void 0 ? t : null,
+      resolution: n,
+      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 n = this.getResolution();
+    return n !== void 0 && (t = this.getZoomForResolution(n)), 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 n = this.minZoom_ || 0, i, s;
+    if (this.resolutions_) {
+      const r = Ut(this.resolutions_, t, 1);
+      n = r, i = this.resolutions_[r], r == this.resolutions_.length - 1 ? s = 2 : s = i / this.resolutions_[r + 1];
+    } else
+      i = this.maxResolution_, s = this.zoomFactor_;
+    return n + Math.log(i / t) / Math.log(s);
+  }
+  /**
+   * 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 n = p(
+        Math.floor(t),
+        0,
+        this.resolutions_.length - 2
+      ), i = this.resolutions_[n] / this.resolutions_[n + 1];
+      return this.resolutions_[n] / Math.pow(i, p(t - n, 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, n) {
+    let i;
+    if (S(
+      Array.isArray(t) || typeof /** @type {?} */
+      t.getSimplifiedGeometry == "function",
+      24
+    ), Array.isArray(t)) {
+      S(!et(t), 25);
+      const s = D(t, this.getProjection());
+      i = Xt(s);
+    } else if (t.getType() === "Circle") {
+      const s = D(
+        t.getExtent(),
+        this.getProjection()
+      );
+      i = Xt(s), i.rotate(this.getRotation(), j(s));
+    } else
+      i = t;
+    this.fitInternal(i, n);
+  }
+  /**
+   * 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 n = this.getRotation(), i = Math.cos(n), s = Math.sin(-n), r = t.getFlatCoordinates(), o = t.getStride();
+    let u = 1 / 0, a = 1 / 0, c = -1 / 0, l = -1 / 0;
+    for (let h = 0, g = r.length; h < g; h += o) {
+      const f = r[h] * i - r[h + 1] * s, d = r[h] * s + r[h + 1] * i;
+      u = Math.min(u, f), a = Math.min(a, d), c = Math.max(c, f), l = Math.max(l, d);
+    }
+    return [u, a, c, l];
+  }
+  /**
+   * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
+   * @param {FitOptions} [options] Options.
+   */
+  fitInternal(t, n) {
+    n = n || {};
+    let i = n.size;
+    i || (i = this.getViewportSizeMinusPadding_());
+    const s = n.padding !== void 0 ? n.padding : [0, 0, 0, 0], r = n.nearest !== void 0 ? n.nearest : !1;
+    let o;
+    n.minResolution !== void 0 ? o = n.minResolution : n.maxZoom !== void 0 ? o = this.getResolutionForZoom(n.maxZoom) : o = 0;
+    const u = this.rotatedExtentForGeometry(t);
+    let a = this.getResolutionForExtentInternal(u, [
+      i[0] - s[1] - s[3],
+      i[1] - s[0] - s[2]
+    ]);
+    a = isNaN(a) ? o : Math.max(a, o), a = this.getConstrainedResolution(a, r ? 0 : 1);
+    const c = this.getRotation(), l = Math.sin(c), h = Math.cos(c), g = j(u);
+    g[0] += (s[1] - s[3]) / 2 * a, g[1] += (s[0] - s[2]) / 2 * a;
+    const f = g[0] * h - g[1] * l, d = g[1] * h + g[0] * l, _ = this.getConstrainedCenter([f, d], a), R = n.callback ? n.callback : pe;
+    n.duration !== void 0 ? this.animateInternal(
+      {
+        resolution: a,
+        center: _,
+        duration: n.duration,
+        easing: n.easing
+      },
+      R
+    ) : (this.targetResolution_ = a, this.targetCenter_ = _, this.applyTargetState_(!1, !0), W(R, !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, n, i) {
+    this.centerOnInternal(
+      w(t, this.getProjection()),
+      n,
+      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, n, i) {
+    this.setCenterInternal(
+      ot(
+        t,
+        n,
+        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, n, i, s) {
+    let r;
+    const o = this.padding_;
+    if (o && t) {
+      const u = this.getViewportSizeMinusPadding_(-i), a = ot(
+        t,
+        s,
+        [u[0] / 2 + o[3], u[1] / 2 + o[0]],
+        n,
+        i
+      );
+      r = [
+        t[0] - a[0],
+        t[1] - a[1]
+      ];
+    }
+    return r;
+  }
+  /**
+   * @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 n = Ot(this.targetCenter_, this.getProjection());
+    this.setCenter([
+      n[0] + t[0],
+      n[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 n = this.targetCenter_;
+    this.setCenterInternal([
+      n[0] + t[0],
+      n[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, n) {
+    n = n && w(n, this.getProjection()), this.adjustResolutionInternal(t, n);
+  }
+  /**
+   * 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, n) {
+    const i = this.getAnimating() || this.getInteracting(), s = this.getViewportSize_(this.getRotation()), r = this.constraints_.resolution(
+      this.targetResolution_ * t,
+      0,
+      s,
+      i
+    );
+    n && (this.targetCenter_ = this.calculateCenterZoom(r, n)), 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, n) {
+    this.adjustResolution(Math.pow(this.zoomFactor_, -t), n);
+  }
+  /**
+   * 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, n) {
+    n && (n = w(n, this.getProjection())), this.adjustRotationInternal(t, n);
+  }
+  /**
+   * @param {number} delta Relative value to add to the zoom rotation, in radians.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
+   */
+  adjustRotationInternal(t, n) {
+    const i = this.getAnimating() || this.getInteracting(), s = this.constraints_.rotation(
+      this.targetRotation_ + t,
+      i
+    );
+    n && (this.targetCenter_ = this.calculateCenterRotate(s, n)), 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, n) {
+    return this.hints_[t] += n, 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, n) {
+    const i = this.getAnimating() || this.getInteracting() || n, s = this.constraints_.rotation(
+      this.targetRotation_,
+      i
+    ), r = this.getViewportSize_(s), o = this.constraints_.resolution(
+      this.targetResolution_,
+      0,
+      r,
+      i
+    ), u = this.constraints_.center(
+      this.targetCenter_,
+      o,
+      r,
+      i,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        o,
+        s,
+        r
+      )
+    );
+    this.get(I.ROTATION) !== s && this.set(I.ROTATION, s), this.get(I.RESOLUTION) !== o && (this.set(I.RESOLUTION, o), this.set("zoom", this.getZoom(), !0)), (!u || !this.get(I.CENTER) || !q(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, n, i) {
+    t = t !== void 0 ? t : 200;
+    const s = n || 0, r = this.constraints_.rotation(this.targetRotation_), o = this.getViewportSize_(r), u = this.constraints_.resolution(
+      this.targetResolution_,
+      s,
+      o
+    ), a = this.constraints_.center(
+      this.targetCenter_,
+      u,
+      o,
+      !1,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        u,
+        r,
+        o
+      )
+    );
+    if (t === 0 && !this.cancelAnchor_) {
+      this.targetResolution_ = u, this.targetRotation_ = r, this.targetCenter_ = a, this.applyTargetState_();
+      return;
+    }
+    i = i || (t === 0 ? this.cancelAnchor_ : void 0), this.cancelAnchor_ = void 0, (this.getResolution() !== u || this.getRotation() !== r || !this.getCenterInternal() || !q(this.getCenterInternal(), a)) && (this.getAnimating() && this.cancelAnimations(), this.animateInternal({
+      rotation: r,
+      center: a,
+      resolution: u,
+      duration: t,
+      easing: we,
+      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(T.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, n, i) {
+    i = i && w(i, this.getProjection()), this.endInteractionInternal(t, n, 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, n, i) {
+    this.getInteracting() && (this.setHint(T.INTERACTING, -1), this.resolveConstraints(t, n, 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, n) {
+    const i = this.getViewportSize_(this.getRotation());
+    return this.constraints_.center(
+      t,
+      n || 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, n) {
+    const i = this.getResolutionForZoom(t);
+    return this.getZoomForResolution(
+      this.getConstrainedResolution(i, n)
+    );
+  }
+  /**
+   * 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, n) {
+    n = n || 0;
+    const i = this.getViewportSize_(this.getRotation());
+    return this.constraints_.resolution(t, n, i);
+  }
+}
+function W(e, t) {
+  setTimeout(function() {
+    e(t);
+  }, 0);
+}
+function xn(e) {
+  if (e.extent !== void 0) {
+    const n = e.smoothExtentConstraint !== void 0 ? e.smoothExtentConstraint : !0;
+    return Lt(e.extent, e.constrainOnlyCenter, n);
+  }
+  const t = gt(e.projection, "EPSG:3857");
+  if (e.multiWorld !== !0 && t.isGlobal()) {
+    const n = t.getExtent().slice();
+    return n[0] = -1 / 0, n[2] = 1 / 0, Lt(n, !1, !1);
+  }
+  return Nn;
+}
+function bn(e) {
+  let t, n, i, o = e.minZoom !== void 0 ? e.minZoom : rt, u = e.maxZoom !== void 0 ? e.maxZoom : 28;
+  const a = e.zoomFactor !== void 0 ? e.zoomFactor : 2, c = e.multiWorld !== void 0 ? e.multiWorld : !1, l = e.smoothResolutionConstraint !== void 0 ? e.smoothResolutionConstraint : !0, h = e.showFullExtent !== void 0 ? e.showFullExtent : !1, g = gt(e.projection, "EPSG:3857"), f = g.getExtent();
+  let d = e.constrainOnlyCenter, _ = e.extent;
+  if (!c && !_ && g.isGlobal() && (d = !1, _ = f), e.resolutions !== void 0) {
+    const R = e.resolutions;
+    n = R[o], i = R[u] !== void 0 ? R[u] : R[R.length - 1], e.constrainResolution ? t = On(
+      R,
+      l,
+      !d && _,
+      h
+    ) : t = jt(
+      n,
+      i,
+      l,
+      !d && _,
+      h
+    );
+  } else {
+    const M = (f ? Math.max(A(f), X(f)) : (
+      // use an extent that can fit the whole world if need be
+      360 * qt.degrees / g.getMetersPerUnit()
+    )) / Pn / Math.pow(2, rt), y = M / Math.pow(2, 28 - rt);
+    n = e.maxResolution, n !== void 0 ? o = 0 : n = M / Math.pow(a, o), i = e.minResolution, i === void 0 && (e.maxZoom !== void 0 ? e.maxResolution !== void 0 ? i = n / Math.pow(a, u) : i = M / Math.pow(a, u) : i = y), u = o + Math.floor(
+      Math.log(n / i) / Math.log(a)
+    ), i = n / Math.pow(a, u - o), e.constrainResolution ? t = Fn(
+      a,
+      n,
+      i,
+      l,
+      !d && _,
+      h
+    ) : t = jt(
+      n,
+      i,
+      l,
+      !d && _,
+      h
+    );
+  }
+  return {
+    constraint: t,
+    maxResolution: n,
+    minResolution: i,
+    minZoom: o,
+    zoomFactor: a
+  };
+}
+function Zn(e) {
+  if (e.enableRotation !== void 0 ? e.enableRotation : !0) {
+    const n = e.constrainRotation;
+    return n === void 0 || n === !0 ? An() : n === !1 ? Gt : typeof n == "number" ? pn(n) : Gt;
+  }
+  return Sn;
+}
+function Xn(e) {
+  return !(e.sourceCenter && e.targetCenter && !q(e.sourceCenter, e.targetCenter) || e.sourceResolution !== e.targetResolution || e.sourceRotation !== e.targetRotation);
+}
+function ot(e, t, n, i, s) {
+  const r = Math.cos(-s);
+  let o = Math.sin(-s), u = e[0] * r - e[1] * o, a = e[1] * r + e[0] * o;
+  u += (t[0] / 2 - n[0]) * i, a += (n[1] - t[1] / 2) * i, o = -o;
+  const c = u * r - a * o, l = a * r + u * o;
+  return [c, l];
+}
+class Fi extends wn {
+  /**
+   * @param {Options<SourceType>} options Layer options.
+   */
+  constructor(t) {
+    const n = Object.assign({}, t);
+    delete n.source, super(n), 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_ && (it(this.sourceChangeKey_), this.sourceChangeKey_ = null), this.sourceReady_ = !1;
+    const t = this.getSource();
+    t && (this.sourceChangeKey_ = st(
+      t,
+      St.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 n;
+    const i = this.getMapInternal();
+    !t && i && (t = i.getView()), t instanceof vt ? n = {
+      viewState: t.getState(),
+      extent: t.calculateExtent()
+    } : n = t, !n.layerStatesArray && i && (n.layerStatesArray = i.getLayerGroup().getLayerStatesArray());
+    let s;
+    n.layerStatesArray ? s = n.layerStatesArray.find(
+      (o) => o.layer === this
+    ) : s = this.getLayerState();
+    const r = this.getExtent();
+    return Gn(s, n.viewState) && (!r || ct(r, n.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 n;
+    const i = this.getSource();
+    if (i && (n = i.getAttributions()), !n)
+      return [];
+    const s = t instanceof vt ? t.getViewStateAndExtent() : t;
+    let r = n(s);
+    return Array.isArray(r) || (r = [r]), r;
+  }
+  /**
+   * 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, n) {
+    const i = this.getRenderer();
+    return i.prepareFrame(t) ? (this.rendered = !0, i.renderFrame(t, n)) : 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_ && (it(this.mapPrecomposeKey_), this.mapPrecomposeKey_ = null), t || this.changed(), this.mapRenderKey_ && (it(this.mapRenderKey_), this.mapRenderKey_ = null), t && (this.mapPrecomposeKey_ = st(
+      t,
+      Tn.PRECOMPOSE,
+      function(n) {
+        const s = /** @type {import("../render/Event.js").default} */ n.frameState.layerStatesArray, r = this.getLayerState(!1);
+        S(
+          !s.some(function(o) {
+            return o.layer === r.layer;
+          }),
+          67
+        ), s.push(r);
+      },
+      this
+    ), this.mapRenderKey_ = st(this, St.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 Gn(e, t) {
+  if (!e.visible)
+    return !1;
+  const n = t.resolution;
+  if (n < e.minResolution || n >= e.maxResolution)
+    return !1;
+  const i = t.zoom;
+  return i > e.minZoom && i <= e.maxZoom;
+}
+class xi extends H {
+  /**
+   * @param {Options} options Source options.
+   */
+  constructor(t) {
+    super(), this.projection = P(t.projection), this.attributions_ = zt(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 n = this;
+    this.viewPromise_ = new Promise(function(i, s) {
+      n.viewResolver = i, n.viewRejector = s;
+    });
+  }
+  /**
+   * 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_ = zt(t), this.changed();
+  }
+  /**
+   * Set the state of the source.
+   * @param {import("./Source.js").State} state State.
+   */
+  setState(t) {
+    this.state_ = t, this.changed();
+  }
+}
+function zt(e) {
+  return e ? Array.isArray(e) ? function(t) {
+    return e;
+  } : typeof e == "function" ? e : function(t) {
+    return [e];
+  } : null;
+}
+export {
+  m as $,
+  mi as A,
+  Ii as B,
+  Ai as C,
+  Pi as D,
+  Ei as E,
+  wi as F,
+  Ti as G,
+  Ci as H,
+  z as I,
+  pi as J,
+  yi as K,
+  Fi as L,
+  dn as M,
+  tt as N,
+  Dn as O,
+  Mt as P,
+  j as Q,
+  Vn as R,
+  xi as S,
+  Q as T,
+  qn as U,
+  Ne as V,
+  un as W,
+  oi as X,
+  ci as Y,
+  li as Z,
+  ln as _,
+  ii as a,
+  Xe as a$,
+  Tn as a0,
+  fi as a1,
+  A as a2,
+  T as a3,
+  zn as a4,
+  ui as a5,
+  gi as a6,
+  _t as a7,
+  vn as a8,
+  Oe as a9,
+  x as aA,
+  ct as aB,
+  hn as aC,
+  ee as aD,
+  ai as aE,
+  xe as aF,
+  _i as aG,
+  hi as aH,
+  di as aI,
+  ti as aJ,
+  ze as aK,
+  we as aL,
+  Ze as aM,
+  Rn as aN,
+  jn as aO,
+  Hn as aP,
+  Je as aQ,
+  Sn as aR,
+  Ae as aS,
+  $ as aT,
+  Wn as aU,
+  ei as aV,
+  kn as aW,
+  Ge as aX,
+  Gn as aY,
+  wn as aZ,
+  vt as a_,
+  Jn as aa,
+  w as ab,
+  q as ac,
+  Ot as ad,
+  D as ae,
+  on as af,
+  Ht as ag,
+  He as ah,
+  Qn as ai,
+  bt as aj,
+  $n as ak,
+  Ni as al,
+  kt as am,
+  Pn as an,
+  Cn as ao,
+  X as ap,
+  qt as aq,
+  Kn as ar,
+  Oi as as,
+  Yn as at,
+  Bt as au,
+  Kt as av,
+  Wt as aw,
+  pt as ax,
+  C as ay,
+  Un as az,
+  te as b,
+  et as b0,
+  en as b1,
+  $e as b2,
+  P as c,
+  Rt as d,
+  si as e,
+  ni as f,
+  Bn as g,
+  Yt as h,
+  se as i,
+  yn as j,
+  ce as k,
+  ue as l,
+  ne as m,
+  yt as n,
+  oe as o,
+  ie as p,
+  re as q,
+  he as r,
+  Mi as s,
+  ri as t,
+  Si as u,
+  ae as v,
+  Vt as w,
+  Fe as x,
+  J as y,
+  Ri as z
+};