@datagouv/components-next 0.2.0 → 1.0.1

package/dist/View-DcDc7N2K.js

@@ -0,0 +1,2858 @@
+import { a6 as p, B as it, m as jt, F as Ft, ak as x, s as Tt, aL as Et, C as vt, D as F, aj as q, k as St, w as S, y as j, n as Zt, aM as zt, r as st, A as Pt, z as Xt, a1 as Yt, J as ot, x as bt, L as rt, K as G, al as Gt, aN as L, M as Lt, ae as Y, aa as y, j as E, U as W, aE as Ot, aO as Vt, af as K, t as kt, P as Ut, V as Dt, aP as Ht } from "./proj-CKwYjU38.js";
+import { d as qt, e as Wt, q as at, u as Kt, v as $t, a as N, j as Bt, w as Jt } from "./common-C4rDcQpp.js";
+const I = {
+  ANIMATING: 0,
+  INTERACTING: 1
+}, M = {
+  CENTER: "center",
+  RESOLUTION: "resolution",
+  ROTATION: "rotation"
+};
+function $(s, t, e) {
+  return (
+    /**
+     * @param {import("./coordinate.js").Coordinate|undefined} center Center.
+     * @param {number|undefined} resolution Resolution.
+     * @param {import("./size.js").Size} size Viewport size; unused if `onlyCenter` was specified.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @param {Array<number>} [centerShift] Shift between map center and viewport center.
+     * @return {import("./coordinate.js").Coordinate|undefined} Center.
+     */
+    (function(n, i, r, o, l) {
+      if (!n)
+        return;
+      if (!i && !t)
+        return n;
+      const a = t ? 0 : r[0] * i, c = t ? 0 : r[1] * i, h = l ? l[0] : 0, u = l ? l[1] : 0;
+      let g = s[0] + a / 2 + h, d = s[2] - a / 2 + h, f = s[1] + c / 2 + u, R = s[3] - c / 2 + u;
+      g > d && (g = (d + g) / 2, d = g), f > R && (f = (R + f) / 2, R = f);
+      let _ = p(n[0], g, d), C = p(n[1], f, R);
+      if (o && e && i) {
+        const m = 30 * i;
+        _ += -m * Math.log(1 + Math.max(0, g - n[0]) / m) + m * Math.log(1 + Math.max(0, n[0] - d) / m), C += -m * Math.log(1 + Math.max(0, f - n[1]) / m) + m * Math.log(1 + Math.max(0, n[1] - R) / m);
+      }
+      return [_, C];
+    })
+  );
+}
+function Qt(s) {
+  return s;
+}
+function lt(s, t, e, n, i, r, o) {
+  r = r || [], o = o || 2;
+  let l = 0;
+  for (let a = t; a < e; a += n) {
+    const c = s[a], h = s[a + 1];
+    r[l++] = i[0] * c + i[2] * h + i[4], r[l++] = i[1] * c + i[3] * h + i[5];
+    for (let u = 2; u < o; u++)
+      r[l++] = s[a + u];
+  }
+  return r && r.length != l && (r.length = l), r;
+}
+function te(s, t, e, n, i, r, o) {
+  o = o || [];
+  const l = Math.cos(i), a = Math.sin(i), c = r[0], h = r[1];
+  let u = 0;
+  for (let g = t; g < e; g += n) {
+    const d = s[g] - c, f = s[g + 1] - h;
+    o[u++] = c + d * l - f * a, o[u++] = h + d * a + f * l;
+    for (let R = g + 2; R < g + n; ++R)
+      o[u++] = s[R];
+  }
+  return o && o.length != u && (o.length = u), o;
+}
+function ee(s, t, e, n, i, r, o, l) {
+  l = l || [];
+  const a = o[0], c = o[1];
+  let h = 0;
+  for (let u = t; u < e; u += n) {
+    const g = s[u] - a, d = s[u + 1] - c;
+    l[h++] = a + i * g, l[h++] = c + r * d;
+    for (let f = u + 2; f < u + n; ++f)
+      l[h++] = s[f];
+  }
+  return l && l.length != h && (l.length = h), l;
+}
+function ne(s, t, e, n, i, r, o) {
+  o = o || [];
+  let l = 0;
+  for (let a = t; a < e; a += n) {
+    o[l++] = s[a] + i, o[l++] = s[a + 1] + r;
+    for (let c = a + 2; c < a + n; ++c)
+      o[l++] = s[c];
+  }
+  return o && o.length != l && (o.length = l), o;
+}
+const B = Wt(), ie = [NaN, NaN];
+class se extends it {
+  constructor() {
+    super(), this.extent_ = jt(), this.extentRevision_ = -1, this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = 0, this.simplifyTransformedInternal = Ft(
+      (t, e, n) => {
+        if (!n)
+          return this.getSimplifiedGeometry(e);
+        const i = this.clone();
+        return i.applyTransform(n), i.getSimplifiedGeometry(e);
+      }
+    );
+  }
+  /**
+   * Get a transformed and simplified version of the geometry.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @param {import("../proj.js").TransformFunction} [transform] Optional transform function.
+   * @return {Geometry} Simplified geometry.
+   */
+  simplifyTransformed(t, e) {
+    return this.simplifyTransformedInternal(
+      this.getRevision(),
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @abstract
+   * @return {!Geometry} Clone.
+   */
+  clone() {
+    return x();
+  }
+  /**
+   * @abstract
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, n, i) {
+    return x();
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    return this.closestPointXY(t, e, ie, Number.MIN_VALUE) === 0;
+  }
+  /**
+   * Return the closest point of the geometry to the passed point as
+   * {@link module:ol/coordinate~Coordinate coordinate}.
+   * @param {import("../coordinate.js").Coordinate} point Point.
+   * @param {import("../coordinate.js").Coordinate} [closestPoint] Closest point.
+   * @return {import("../coordinate.js").Coordinate} Closest point.
+   * @api
+   */
+  getClosestPoint(t, e) {
+    return e = e || [NaN, NaN], this.closestPointXY(t[0], t[1], e, 1 / 0), e;
+  }
+  /**
+   * Returns true if this geometry includes the specified coordinate. If the
+   * coordinate is on the boundary of the geometry, returns false.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @return {boolean} Contains coordinate.
+   * @api
+   */
+  intersectsCoordinate(t) {
+    return this.containsXY(t[0], t[1]);
+  }
+  /**
+   * @abstract
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   */
+  computeExtent(t) {
+    return x();
+  }
+  /**
+   * Get the extent of the geometry.
+   * @param {import("../extent.js").Extent} [extent] Extent.
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  getExtent(t) {
+    if (this.extentRevision_ != this.getRevision()) {
+      const e = this.computeExtent(this.extent_);
+      (isNaN(e[0]) || isNaN(e[1])) && Tt(e), this.extentRevision_ = this.getRevision();
+    }
+    return Et(this.extent_, t);
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} angle Rotation angle in radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   */
+  rotate(t, e) {
+    x();
+  }
+  /**
+   * Scale the geometry (with an optional origin).  This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} sx The scaling factor in the x-direction.
+   * @param {number} [sy] The scaling factor in the y-direction (defaults to sx).
+   * @param {import("../coordinate.js").Coordinate} [anchor] The scale origin (defaults to the center
+   *     of the geometry extent).
+   * @api
+   */
+  scale(t, e, n) {
+    x();
+  }
+  /**
+   * 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 x();
+  }
+  /**
+   * Get the type of this geometry.
+   * @abstract
+   * @return {Type} Geometry type.
+   */
+  getType() {
+    return x();
+  }
+  /**
+   * 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) {
+    x();
+  }
+  /**
+   * 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 x();
+  }
+  /**
+   * Translate the geometry.  This modifies the geometry coordinates in place.  If
+   * instead you want a new geometry, first `clone()` this geometry.
+   * @abstract
+   * @param {number} deltaX Delta X.
+   * @param {number} deltaY Delta Y.
+   * @api
+   */
+  translate(t, e) {
+    x();
+  }
+  /**
+   * 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 {this} This geometry.  Note that original geometry is
+   *     modified in place.
+   * @api
+   */
+  transform(t, e) {
+    const n = vt(t), i = n.getUnits() == "tile-pixels" ? function(r, o, l) {
+      const a = n.getExtent(), c = n.getWorldExtent(), h = F(c) / F(a);
+      qt(
+        B,
+        c[0],
+        c[3],
+        h,
+        -h,
+        0,
+        0,
+        0
+      );
+      const u = lt(
+        r,
+        0,
+        r.length,
+        l,
+        B,
+        o
+      ), g = q(n, e);
+      return g ? g(u, u, l) : u;
+    } : q(n, e);
+    return this.applyTransform(i), this;
+  }
+}
+class O extends se {
+  constructor() {
+    super(), this.layout = "XY", this.stride = 2, this.flatCoordinates;
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @override
+   */
+  computeExtent(t) {
+    return St(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * @abstract
+   * @return {Array<*> | null} Coordinates.
+   */
+  getCoordinates() {
+    return x();
+  }
+  /**
+   * 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.
+   * @override
+   */
+  getSimplifiedGeometry(t) {
+    if (this.simplifiedGeometryRevision !== this.getRevision() && (this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = this.getRevision()), t < 0 || this.simplifiedGeometryMaxMinSquaredTolerance !== 0 && t <= this.simplifiedGeometryMaxMinSquaredTolerance)
+      return this;
+    const e = this.getSimplifiedGeometryInternal(t);
+    return e.getFlatCoordinates().length < this.flatCoordinates.length ? e : (this.simplifiedGeometryMaxMinSquaredTolerance = t, this);
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {SimpleGeometry} Simplified geometry.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    return this;
+  }
+  /**
+   * @return {number} Stride.
+   */
+  getStride() {
+    return this.stride;
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout} layout Layout.
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   */
+  setFlatCoordinates(t, e) {
+    this.stride = J(t), this.layout = t, this.flatCoordinates = e;
+  }
+  /**
+   * @abstract
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  setCoordinates(t, e) {
+    x();
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout|undefined} layout Layout.
+   * @param {Array<*>} coordinates Coordinates.
+   * @param {number} nesting Nesting.
+   * @protected
+   */
+  setLayout(t, e, n) {
+    let i;
+    if (t)
+      i = J(t);
+    else {
+      for (let r = 0; r < n; ++r) {
+        if (e.length === 0) {
+          this.layout = "XY", this.stride = 2;
+          return;
+        }
+        e = /** @type {Array<unknown>} */
+        e[0];
+      }
+      i = e.length, t = oe(i);
+    }
+    this.layout = t, this.stride = i;
+  }
+  /**
+   * 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
+   * @override
+   */
+  applyTransform(t) {
+    this.flatCoordinates && (t(
+      this.flatCoordinates,
+      this.flatCoordinates,
+      this.layout.startsWith("XYZ") ? 3 : 2,
+      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
+   * @override
+   */
+  rotate(t, e) {
+    const n = this.getFlatCoordinates();
+    if (n) {
+      const i = this.getStride();
+      te(
+        n,
+        0,
+        n.length,
+        i,
+        t,
+        e,
+        n
+      ), 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
+   * @override
+   */
+  scale(t, e, n) {
+    e === void 0 && (e = t), n || (n = S(this.getExtent()));
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const r = this.getStride();
+      ee(
+        i,
+        0,
+        i.length,
+        r,
+        t,
+        e,
+        n,
+        i
+      ), 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
+   * @override
+   */
+  translate(t, e) {
+    const n = this.getFlatCoordinates();
+    if (n) {
+      const i = this.getStride();
+      ne(
+        n,
+        0,
+        n.length,
+        i,
+        t,
+        e,
+        n
+      ), this.changed();
+    }
+  }
+}
+function oe(s) {
+  let t;
+  return s == 2 ? t = "XY" : s == 3 ? t = "XYZ" : s == 4 && (t = "XYZM"), /** @type {import("./Geometry.js").GeometryLayout} */
+  t;
+}
+function J(s) {
+  let t;
+  return s == "XY" ? t = 2 : s == "XYZ" || s == "XYM" ? t = 3 : s == "XYZM" && (t = 4), /** @type {number} */
+  t;
+}
+function me(s, t, e) {
+  const n = s.getFlatCoordinates();
+  if (!n)
+    return null;
+  const i = s.getStride();
+  return lt(
+    n,
+    0,
+    n.length,
+    i,
+    t,
+    e
+  );
+}
+function ht(s, t, e, n) {
+  let i = 0;
+  const r = s[e - n], o = s[e - n + 1];
+  let l = 0, a = 0;
+  for (; t < e; t += n) {
+    const c = s[t] - r, h = s[t + 1] - o;
+    i += a * c - l * h, l = c, a = h;
+  }
+  return i / 2;
+}
+function ut(s, t, e, n) {
+  let i = 0;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r];
+    i += ht(s, t, l, n), t = l;
+  }
+  return i;
+}
+function Ce(s, t, e, n) {
+  let i = 0;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r];
+    i += ut(s, t, l, n), t = l[l.length - 1];
+  }
+  return i;
+}
+function Q(s, t, e, n, i, r, o) {
+  const l = s[t], a = s[t + 1], c = s[e] - l, h = s[e + 1] - a;
+  let u;
+  if (c === 0 && h === 0)
+    u = t;
+  else {
+    const g = ((i - l) * c + (r - a) * h) / (c * c + h * h);
+    if (g > 1)
+      u = e;
+    else if (g > 0) {
+      for (let d = 0; d < n; ++d)
+        o[d] = Zt(
+          s[t + d],
+          s[e + d],
+          g
+        );
+      o.length = n;
+      return;
+    } else
+      u = t;
+  }
+  for (let g = 0; g < n; ++g)
+    o[g] = s[u + g];
+  o.length = n;
+}
+function ct(s, t, e, n, i) {
+  let r = s[t], o = s[t + 1];
+  for (t += n; t < e; t += n) {
+    const l = s[t], a = s[t + 1], c = j(r, o, l, a);
+    c > i && (i = c), r = l, o = a;
+  }
+  return i;
+}
+function gt(s, t, e, n, i) {
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r];
+    i = ct(s, t, l, n, i), t = l;
+  }
+  return i;
+}
+function xe(s, t, e, n, i) {
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r];
+    i = gt(s, t, l, n, i), t = l[l.length - 1];
+  }
+  return i;
+}
+function dt(s, t, e, n, i, r, o, l, a, c, h) {
+  if (t == e)
+    return c;
+  let u, g;
+  if (i === 0) {
+    if (g = j(
+      o,
+      l,
+      s[t],
+      s[t + 1]
+    ), g < c) {
+      for (u = 0; u < n; ++u)
+        a[u] = s[t + u];
+      return a.length = n, g;
+    }
+    return c;
+  }
+  h = h || [NaN, NaN];
+  let d = t + n;
+  for (; d < e; )
+    if (Q(
+      s,
+      d - n,
+      d,
+      n,
+      o,
+      l,
+      h
+    ), g = j(o, l, h[0], h[1]), g < c) {
+      for (c = g, u = 0; u < n; ++u)
+        a[u] = h[u];
+      a.length = n, d += n;
+    } else
+      d += n * Math.max(
+        (Math.sqrt(g) - Math.sqrt(c)) / i | 0,
+        1
+      );
+  if (r && (Q(
+    s,
+    e - n,
+    t,
+    n,
+    o,
+    l,
+    h
+  ), g = j(o, l, h[0], h[1]), g < c)) {
+    for (c = g, u = 0; u < n; ++u)
+      a[u] = h[u];
+    a.length = n;
+  }
+  return c;
+}
+function ft(s, t, e, n, i, r, o, l, a, c, h) {
+  h = h || [NaN, NaN];
+  for (let u = 0, g = e.length; u < g; ++u) {
+    const d = e[u];
+    c = dt(
+      s,
+      t,
+      d,
+      n,
+      i,
+      r,
+      o,
+      l,
+      a,
+      c,
+      h
+    ), t = d;
+  }
+  return c;
+}
+function Me(s, t, e, n, i, r, o, l, a, c, h) {
+  h = h || [NaN, NaN];
+  for (let u = 0, g = e.length; u < g; ++u) {
+    const d = e[u];
+    c = ft(
+      s,
+      t,
+      d,
+      n,
+      i,
+      r,
+      o,
+      l,
+      a,
+      c,
+      h
+    ), t = d[d.length - 1];
+  }
+  return c;
+}
+function re(s, t, e, n) {
+  for (let i = 0, r = e.length; i < r; ++i)
+    s[t++] = e[i];
+  return t;
+}
+function Rt(s, t, e, n) {
+  for (let i = 0, r = e.length; i < r; ++i) {
+    const o = e[i];
+    for (let l = 0; l < n; ++l)
+      s[t++] = o[l];
+  }
+  return t;
+}
+function _t(s, t, e, n, i) {
+  i = i || [];
+  let r = 0;
+  for (let o = 0, l = e.length; o < l; ++o) {
+    const a = Rt(
+      s,
+      t,
+      e[o],
+      n
+    );
+    i[r++] = a, t = a;
+  }
+  return i.length = r, i;
+}
+function pe(s, t, e, n, i) {
+  i = i || [];
+  let r = 0;
+  for (let o = 0, l = e.length; o < l; ++o) {
+    const a = _t(
+      s,
+      t,
+      e[o],
+      n,
+      i[r]
+    );
+    a.length === 0 && (a[0] = t), i[r++] = a, t = a[a.length - 1];
+  }
+  return i.length = r, i;
+}
+function mt(s, t, e, n, i) {
+  i = i !== void 0 ? i : [];
+  let r = 0;
+  for (let o = t; o < e; o += n)
+    i[r++] = s.slice(o, o + n);
+  return i.length = r, i;
+}
+function Ct(s, t, e, n, i) {
+  i = i !== void 0 ? i : [];
+  let r = 0;
+  for (let o = 0, l = e.length; o < l; ++o) {
+    const a = e[o];
+    i[r++] = mt(
+      s,
+      t,
+      a,
+      n,
+      i[r]
+    ), t = a;
+  }
+  return i.length = r, i;
+}
+function ye(s, t, e, n, i) {
+  i = i !== void 0 ? i : [];
+  let r = 0;
+  for (let o = 0, l = e.length; o < l; ++o) {
+    const a = e[o];
+    i[r++] = a.length === 1 && a[0] === t ? [] : Ct(
+      s,
+      t,
+      a,
+      n,
+      i[r]
+    ), t = a[a.length - 1];
+  }
+  return i.length = r, i;
+}
+function xt(s, t, e, n, i, r, o) {
+  const l = (e - t) / n;
+  if (l < 3) {
+    for (; t < e; t += n)
+      r[o++] = s[t], r[o++] = s[t + 1];
+    return o;
+  }
+  const a = new Array(l);
+  a[0] = 1, a[l - 1] = 1;
+  const c = [t, e - n];
+  let h = 0;
+  for (; c.length > 0; ) {
+    const u = c.pop(), g = c.pop();
+    let d = 0;
+    const f = s[g], R = s[g + 1], _ = s[u], C = s[u + 1];
+    for (let m = g + n; m < u; m += n) {
+      const z = s[m], w = s[m + 1], H = zt(z, w, f, R, _, C);
+      H > d && (h = m, d = H);
+    }
+    d > i && (a[(h - t) / n] = 1, g + n < h && c.push(g, h), h + n < u && c.push(h, u));
+  }
+  for (let u = 0; u < l; ++u)
+    a[u] && (r[o++] = s[t + u * n], r[o++] = s[t + u * n + 1]);
+  return o;
+}
+function Ie(s, t, e, n, i, r, o, l) {
+  for (let a = 0, c = e.length; a < c; ++a) {
+    const h = e[a];
+    o = xt(
+      s,
+      t,
+      h,
+      n,
+      i,
+      r,
+      o
+    ), l.push(o), t = h;
+  }
+  return o;
+}
+function A(s, t) {
+  return t * Math.round(s / t);
+}
+function ae(s, t, e, n, i, r, o) {
+  if (t == e)
+    return o;
+  let l = A(s[t], i), a = A(s[t + 1], i);
+  t += n, r[o++] = l, r[o++] = a;
+  let c, h;
+  do
+    if (c = A(s[t], i), h = A(s[t + 1], i), t += n, t == e)
+      return r[o++] = c, r[o++] = h, o;
+  while (c == l && h == a);
+  for (; t < e; ) {
+    const u = A(s[t], i), g = A(s[t + 1], i);
+    if (t += n, u == c && g == h)
+      continue;
+    const d = c - l, f = h - a, R = u - l, _ = g - a;
+    if (d * _ == f * R && (d < 0 && R < d || d == R || d > 0 && R > d) && (f < 0 && _ < f || f == _ || f > 0 && _ > f)) {
+      c = u, h = g;
+      continue;
+    }
+    r[o++] = c, r[o++] = h, l = c, a = h, c = u, h = g;
+  }
+  return r[o++] = c, r[o++] = h, o;
+}
+function Mt(s, t, e, n, i, r, o, l) {
+  for (let a = 0, c = e.length; a < c; ++a) {
+    const h = e[a];
+    o = ae(
+      s,
+      t,
+      h,
+      n,
+      i,
+      r,
+      o
+    ), l.push(o), t = h;
+  }
+  return o;
+}
+function Ae(s, t, e, n, i, r, o, l) {
+  for (let a = 0, c = e.length; a < c; ++a) {
+    const h = e[a], u = [];
+    o = Mt(
+      s,
+      t,
+      h,
+      n,
+      i,
+      r,
+      o,
+      u
+    ), l.push(u), t = h[h.length - 1];
+  }
+  return o;
+}
+class T extends O {
+  /**
+   * @param {Array<import("../coordinate.js").Coordinate>|Array<number>} coordinates Coordinates.
+   *     For internal use, flat coordinates in combination with `layout` are also accepted.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, e) {
+    super(), this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, e !== void 0 && !Array.isArray(t[0]) ? this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ) : this.setCoordinates(
+      /** @type {Array<import("../coordinate.js").Coordinate>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!LinearRing} Clone.
+   * @api
+   * @override
+   */
+  clone() {
+    return new T(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.
+   * @override
+   */
+  closestPointXY(t, e, n, i) {
+    return i < st(this.getExtent(), t, e) ? i : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      ct(
+        this.flatCoordinates,
+        0,
+        this.flatCoordinates.length,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), dt(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      n,
+      i
+    ));
+  }
+  /**
+   * Return the area of the linear ring on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return ht(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * Return the coordinates of the linear ring.
+   * @return {Array<import("../coordinate.js").Coordinate>} Coordinates.
+   * @api
+   * @override
+   */
+  getCoordinates() {
+    return mt(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {LinearRing} Simplified LinearRing.
+   * @protected
+   * @override
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [];
+    return e.length = xt(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e,
+      0
+    ), new T(e, "XY");
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   * @override
+   */
+  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
+   * @override
+   */
+  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
+   * @override
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 1), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = Rt(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+class V extends O {
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, e) {
+    super(), this.setCoordinates(t, e);
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!Point} Clone.
+   * @api
+   * @override
+   */
+  clone() {
+    const t = new V(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.
+   * @override
+   */
+  closestPointXY(t, e, n, i) {
+    const r = this.flatCoordinates, o = j(
+      t,
+      e,
+      r[0],
+      r[1]
+    );
+    if (o < i) {
+      const l = this.stride;
+      for (let a = 0; a < l; ++a)
+        n[a] = r[a];
+      return n.length = l, o;
+    }
+    return i;
+  }
+  /**
+   * Return the coordinate of the point.
+   * @return {import("../coordinate.js").Coordinate} Coordinates.
+   * @api
+   * @override
+   */
+  getCoordinates() {
+    return this.flatCoordinates.slice();
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @override
+   */
+  computeExtent(t) {
+    return Pt(this.flatCoordinates, t);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   * @override
+   */
+  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
+   * @override
+   */
+  intersectsExtent(t) {
+    return Xt(t, this.flatCoordinates[0], this.flatCoordinates[1]);
+  }
+  /**
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   * @override
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 0), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = re(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+function pt(s, t, e, n, i, r, o) {
+  let l, a, c, h, u, g, d;
+  const f = i[r + 1], R = [];
+  for (let m = 0, z = e.length; m < z; ++m) {
+    const w = e[m];
+    for (h = s[w - n], g = s[w - n + 1], l = t; l < w; l += n)
+      u = s[l], d = s[l + 1], (f <= g && d <= f || g <= f && f <= d) && (c = (f - g) / (d - g) * (u - h) + h, R.push(c)), h = u, g = d;
+  }
+  let _ = NaN, C = -1 / 0;
+  for (R.sort(Yt), h = R[0], l = 1, a = R.length; l < a; ++l) {
+    u = R[l];
+    const m = Math.abs(u - h);
+    m > C && (c = (h + u) / 2, at(s, t, e, n, c, f) && (_ = c, C = m)), h = u;
+  }
+  return isNaN(_) && (_ = i[r]), o ? (o.push(_, f, C), o) : [_, f, C];
+}
+function we(s, t, e, n, i) {
+  let r = [];
+  for (let o = 0, l = e.length; o < l; ++o) {
+    const a = e[o];
+    r = pt(
+      s,
+      t,
+      a,
+      n,
+      i,
+      2 * o,
+      r
+    ), t = a[a.length - 1];
+  }
+  return r;
+}
+function le(s, t, e, n) {
+  for (; t < e - n; ) {
+    for (let i = 0; i < n; ++i) {
+      const r = s[t + i];
+      s[t + i] = s[e - n + i], s[e - n + i] = r;
+    }
+    t += n, e -= n;
+  }
+}
+function k(s, t, e, n) {
+  let i = 0, r = s[e - n], o = s[e - n + 1];
+  for (; t < e; t += n) {
+    const l = s[t], a = s[t + 1];
+    i += (l - r) * (a + o), r = l, o = a;
+  }
+  return i === 0 ? void 0 : i > 0;
+}
+function yt(s, t, e, n, i) {
+  i = i !== void 0 ? i : !1;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r], a = k(
+      s,
+      t,
+      l,
+      n
+    );
+    if (r === 0) {
+      if (i && a || !i && !a)
+        return !1;
+    } else if (i && !a || !i && a)
+      return !1;
+    t = l;
+  }
+  return !0;
+}
+function Ne(s, t, e, n, i) {
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r];
+    if (!yt(s, t, l, n, i))
+      return !1;
+    l.length && (t = l[l.length - 1]);
+  }
+  return !0;
+}
+function b(s, t, e, n, i) {
+  i = i !== void 0 ? i : !1;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const l = e[r], a = k(
+      s,
+      t,
+      l,
+      n
+    );
+    (r === 0 ? i && a || !i && !a : i && !a || !i && a) && le(s, t, l, n), t = l;
+  }
+  return t;
+}
+function je(s, t, e, n, i) {
+  for (let r = 0, o = e.length; r < o; ++r)
+    t = b(
+      s,
+      t,
+      e[r],
+      n,
+      i
+    );
+  return t;
+}
+function Fe(s, t) {
+  const e = [];
+  let n = 0, i = 0, r;
+  for (let o = 0, l = t.length; o < l; ++o) {
+    const a = t[o], c = k(s, n, a, 2);
+    if (r === void 0 && (r = c), c === r)
+      e.push(t.slice(i, o + 1));
+    else {
+      if (e.length === 0)
+        continue;
+      e[e.length - 1].push(t[i]);
+    }
+    i = o + 1, n = a;
+  }
+  return e;
+}
+class Z extends O {
+  /**
+   * @param {!Array<Array<import("../coordinate.js").Coordinate>>|!Array<number>} coordinates
+   *     Array of linear rings that define the polygon. The first linear ring of the
+   *     array defines the outer-boundary or surface of the polygon. Each subsequent
+   *     linear ring defines a hole in the surface of the polygon. A linear ring is
+   *     an array of vertices' coordinates where the first coordinate and the last are
+   *     equivalent. (For internal use, flat coordinates in combination with
+   *     `layout` and `ends` are also accepted.)
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @param {Array<number>} [ends] Ends (for internal use with flat coordinates).
+   */
+  constructor(t, e, n) {
+    super(), this.ends_ = [], this.flatInteriorPointRevision_ = -1, this.flatInteriorPoint_ = null, this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, this.orientedRevision_ = -1, this.orientedFlatCoordinates_ = null, e !== void 0 && n ? (this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ), this.ends_ = n) : this.setCoordinates(
+      /** @type {Array<Array<import("../coordinate.js").Coordinate>>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Append the passed linear ring to this polygon.
+   * @param {LinearRing} linearRing Linear ring.
+   * @api
+   */
+  appendLinearRing(t) {
+    this.flatCoordinates ? bt(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
+   * @override
+   */
+  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.
+   * @override
+   */
+  closestPointXY(t, e, n, i) {
+    return i < st(this.getExtent(), t, e) ? i : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      gt(
+        this.flatCoordinates,
+        0,
+        this.ends_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), ft(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      n,
+      i
+    ));
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   * @override
+   */
+  containsXY(t, e) {
+    return at(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride,
+      t,
+      e
+    );
+  }
+  /**
+   * Return the area of the polygon on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return ut(
+      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
+   * @override
+   */
+  getCoordinates(t) {
+    let e;
+    return t !== void 0 ? (e = this.getOrientedFlatCoordinates().slice(), b(e, 0, this.ends_, this.stride, t)) : e = this.flatCoordinates, Ct(e, 0, this.ends_, this.stride);
+  }
+  /**
+   * @return {Array<number>} Ends.
+   */
+  getEnds() {
+    return this.ends_;
+  }
+  /**
+   * @return {Array<number>} Interior point.
+   */
+  getFlatInteriorPoint() {
+    if (this.flatInteriorPointRevision_ != this.getRevision()) {
+      const t = S(this.getExtent());
+      this.flatInteriorPoint_ = pt(
+        this.getOrientedFlatCoordinates(),
+        0,
+        this.ends_,
+        this.stride,
+        t,
+        0
+      ), this.flatInteriorPointRevision_ = this.getRevision();
+    }
+    return (
+      /** @type {import("../coordinate.js").Coordinate} */
+      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 V(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 T(
+      this.flatCoordinates.slice(
+        t === 0 ? 0 : this.ends_[t - 1],
+        this.ends_[t]
+      ),
+      this.layout
+    );
+  }
+  /**
+   * Return the linear rings of the polygon.
+   * @return {Array<LinearRing>} Linear rings.
+   * @api
+   */
+  getLinearRings() {
+    const t = this.layout, e = this.flatCoordinates, n = this.ends_, i = [];
+    let r = 0;
+    for (let o = 0, l = n.length; o < l; ++o) {
+      const a = n[o], c = new T(
+        e.slice(r, a),
+        t
+      );
+      i.push(c), r = a;
+    }
+    return i;
+  }
+  /**
+   * @return {Array<number>} Oriented flat coordinates.
+   */
+  getOrientedFlatCoordinates() {
+    if (this.orientedRevision_ != this.getRevision()) {
+      const t = this.flatCoordinates;
+      yt(t, 0, this.ends_, this.stride) ? this.orientedFlatCoordinates_ = t : (this.orientedFlatCoordinates_ = t.slice(), this.orientedFlatCoordinates_.length = b(
+        this.orientedFlatCoordinates_,
+        0,
+        this.ends_,
+        this.stride
+      )), this.orientedRevision_ = this.getRevision();
+    }
+    return (
+      /** @type {Array<number>} */
+      this.orientedFlatCoordinates_
+    );
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {Polygon} Simplified Polygon.
+   * @protected
+   * @override
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [], n = [];
+    return e.length = Mt(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      Math.sqrt(t),
+      e,
+      0,
+      n
+    ), new Z(e, "XY", n);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   * @override
+   */
+  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
+   * @override
+   */
+  intersectsExtent(t) {
+    return Kt(
+      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
+   * @override
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 2), this.flatCoordinates || (this.flatCoordinates = []);
+    const n = _t(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.ends_
+    );
+    this.flatCoordinates.length = n.length === 0 ? 0 : n[n.length - 1], this.changed();
+  }
+}
+function tt(s) {
+  if (ot(s))
+    throw new Error("Cannot create polygon from empty extent");
+  const t = s[0], e = s[1], n = s[2], i = s[3], r = [
+    t,
+    e,
+    t,
+    i,
+    n,
+    i,
+    n,
+    e,
+    t,
+    e
+  ];
+  return new Z(r, "XY", [r.length]);
+}
+function U(s, t, e, n) {
+  const i = G(t) / e[0], r = F(t) / e[1];
+  return n ? Math.min(s, Math.max(i, r)) : Math.min(s, Math.min(i, r));
+}
+function D(s, t, e) {
+  let n = Math.min(s, t);
+  const i = 50;
+  return n *= Math.log(1 + i * Math.max(0, s / t - 1)) / i + 1, e && (n = Math.max(n, e), n /= Math.log(1 + i * Math.max(0, e / s - 1)) / i + 1), p(n, e / 2, t * 2);
+}
+function he(s, t, e, n) {
+  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(i, r, o, l) {
+    if (i !== void 0) {
+      const a = s[0], c = s[s.length - 1], h = e ? U(
+        a,
+        e,
+        o,
+        n
+      ) : a;
+      if (l)
+        return t ? D(
+          i,
+          h,
+          c
+        ) : p(i, c, h);
+      const u = Math.min(h, i), g = Math.floor(rt(s, u, r));
+      return s[g] > h && g < s.length - 1 ? s[g + 1] : s[g];
+    }
+  });
+}
+function ue(s, t, e, n, i, r) {
+  return n = n !== void 0 ? n : !0, e = e !== void 0 ? e : 0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  (function(o, l, a, c) {
+    if (o !== void 0) {
+      const h = i ? U(
+        t,
+        i,
+        a,
+        r
+      ) : t;
+      if (c)
+        return n ? D(
+          o,
+          h,
+          e
+        ) : p(o, e, h);
+      const u = 1e-9, g = Math.ceil(
+        Math.log(t / h) / Math.log(s) - u
+      ), d = -l * (0.5 - u) + 0.5, f = Math.min(h, o), R = Math.floor(
+        Math.log(t / f) / Math.log(s) + d
+      ), _ = Math.max(g, R), C = t / Math.pow(s, _);
+      return p(C, e, h);
+    }
+  });
+}
+function et(s, t, e, n, i) {
+  return e = e !== void 0 ? e : !0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  (function(r, o, l, a) {
+    if (r !== void 0) {
+      const c = n ? U(
+        s,
+        n,
+        l,
+        i
+      ) : s;
+      return !e || !a ? p(r, t, c) : D(
+        r,
+        c,
+        t
+      );
+    }
+  });
+}
+function ce(s) {
+  if (s !== void 0)
+    return 0;
+}
+function nt(s) {
+  if (s !== void 0)
+    return s;
+}
+function ge(s) {
+  const t = 2 * Math.PI / s;
+  return (
+    /**
+     * @param {number|undefined} rotation Rotation.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @return {number|undefined} Rotation.
+     */
+    (function(e, n) {
+      if (n)
+        return e;
+      if (e !== void 0)
+        return e = Math.floor(e / t + 0.5) * t, e;
+    })
+  );
+}
+function de(s) {
+  const t = Gt(5);
+  return (
+    /**
+     * @param {number|undefined} rotation Rotation.
+     * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+     * @return {number|undefined} Rotation.
+     */
+    (function(e, n) {
+      return n || e === void 0 ? e : Math.abs(e) <= t ? 0 : e;
+    })
+  );
+}
+const P = 0;
+class fe extends it {
+  /**
+   * @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_ = L(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 && Ht(), t.center && (t.center = y(t.center, this.projection_)), t.extent && (t.extent = E(t.extent, this.projection_)), this.applyOptions_(t);
+  }
+  /**
+   * Set up the view with the given options.
+   * @param {ViewOptions} options View options.
+   */
+  applyOptions_(t) {
+    const e = Object.assign({}, t);
+    for (const l in M)
+      delete e[l];
+    this.setProperties(e, !0);
+    const n = At(t);
+    this.maxResolution_ = n.maxResolution, this.minResolution_ = n.minResolution, this.zoomFactor_ = n.zoomFactor, this.resolutions_ = t.resolutions, this.padding_ = t.padding, this.minZoom_ = n.minZoom;
+    const i = It(t), r = n.constraint, o = wt(t);
+    this.constraints_ = {
+      center: i,
+      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 e = this.padding_;
+    this.padding_ = t;
+    const n = this.getCenterInternal();
+    if (n) {
+      const i = t || [0, 0, 0, 0];
+      e = e || [0, 0, 0, 0];
+      const r = this.getResolution(), o = r / 2 * (i[3] - e[3] + e[1] - i[1]), l = r / 2 * (i[0] - e[0] + e[2] - i[2]);
+      this.setCenterInternal([n[0] + o, n[1] - l]);
+    }
+  }
+  /**
+   * Get an updated version of the view options used to construct the view.  The
+   * current resolution (or zoom), center, and rotation are applied to any stored
+   * options.  The provided options can be used to apply new min/max zoom or
+   * resolution limits.
+   * @param {ViewOptions} newOptions New options to be applied.
+   * @return {ViewOptions} New options updated with the current view state.
+   */
+  getUpdatedOptions_(t) {
+    const e = this.getProperties();
+    return e.resolution !== void 0 ? e.resolution = this.getResolution() : e.zoom = this.getZoom(), e.center = this.getCenterInternal(), e.rotation = this.getRotation(), Object.assign({}, e, t);
+  }
+  /**
+   * Animate the view.  The view's center, zoom (or resolution), and rotation
+   * can be animated for smooth transitions between view states.  For example,
+   * to animate the view to a new zoom level:
+   *
+   *     view.animate({zoom: view.getZoom() + 1});
+   *
+   * By default, the animation lasts one second and uses in-and-out easing.  You
+   * can customize this behavior by including `duration` (in milliseconds) and
+   * `easing` options (see {@link module:ol/easing}).
+   *
+   * To chain together multiple animations, call the method with multiple
+   * animation objects.  For example, to first zoom and then pan:
+   *
+   *     view.animate({zoom: 10}, {center: [0, 0]});
+   *
+   * If you provide a function as the last argument to the animate method, it
+   * will get called at the end of an animation series.  The callback will be
+   * called with `true` if the animation series completed on its own or `false`
+   * if it was cancelled.
+   *
+   * Animations are cancelled by user interactions (e.g. dragging the map) or by
+   * calling `view.setCenter()`, `view.setResolution()`, or `view.setRotation()`
+   * (or another method that calls one of these).
+   *
+   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation
+   *     options.  Multiple animations can be run in series by passing multiple
+   *     options objects.  To run multiple animations in parallel, call the method
+   *     multiple times.  An optional callback can be provided as a final
+   *     argument.  The callback will be called with a boolean indicating whether
+   *     the animation completed without being cancelled.
+   * @api
+   */
+  animate(t) {
+    this.isDef() && !this.getAnimating() && this.resolveConstraints(0);
+    const e = new Array(arguments.length);
+    for (let n = 0; n < e.length; ++n) {
+      let i = arguments[n];
+      i.center && (i = Object.assign({}, i), i.center = y(
+        i.center,
+        this.getProjection()
+      )), i.anchor && (i = Object.assign({}, i), i.anchor = y(
+        i.anchor,
+        this.getProjection()
+      )), e[n] = i;
+    }
+    this.animateInternal.apply(this, e);
+  }
+  /**
+   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation options.
+   */
+  animateInternal(t) {
+    let e = arguments.length, n;
+    e > 1 && typeof arguments[e - 1] == "function" && (n = arguments[e - 1], --e);
+    let i = 0;
+    for (; i < e && !this.isDef(); ++i) {
+      const h = arguments[i];
+      h.center && this.setCenterInternal(h.center), h.zoom !== void 0 ? this.setZoom(h.zoom) : h.resolution && this.setResolution(h.resolution), h.rotation !== void 0 && this.setRotation(h.rotation);
+    }
+    if (i === e) {
+      n && v(n, !0);
+      return;
+    }
+    let r = Date.now(), o = this.targetCenter_.slice(), l = this.targetResolution_, a = this.targetRotation_;
+    const c = [];
+    for (; i < e; ++i) {
+      const h = (
+        /** @type {AnimationOptions} */
+        arguments[i]
+      ), u = {
+        start: r,
+        complete: !1,
+        anchor: h.anchor,
+        duration: h.duration !== void 0 ? h.duration : 1e3,
+        easing: h.easing || $t,
+        callback: n
+      };
+      if (h.center && (u.sourceCenter = o, u.targetCenter = h.center.slice(), o = u.targetCenter), h.zoom !== void 0 ? (u.sourceResolution = l, u.targetResolution = this.getResolutionForZoom(h.zoom), l = u.targetResolution) : h.resolution && (u.sourceResolution = l, u.targetResolution = h.resolution, l = u.targetResolution), h.rotation !== void 0) {
+        u.sourceRotation = a;
+        const g = W(h.rotation - a + Math.PI, 2 * Math.PI) - Math.PI;
+        u.targetRotation = a + g, a = u.targetRotation;
+      }
+      Nt(u) ? u.complete = !0 : r += u.duration, c.push(u);
+    }
+    this.animations_.push(c), this.setHint(I.ANIMATING, 1), this.updateAnimations_();
+  }
+  /**
+   * Determine if the view is being animated.
+   * @return {boolean} The view is being animated.
+   * @api
+   */
+  getAnimating() {
+    return this.hints_[I.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_[I.INTERACTING] > 0;
+  }
+  /**
+   * Cancel any ongoing animations.
+   * @api
+   */
+  cancelAnimations() {
+    this.setHint(I.ANIMATING, -this.hints_[I.ANIMATING]);
+    let t;
+    for (let e = 0, n = this.animations_.length; e < n; ++e) {
+      const i = this.animations_[e];
+      if (i[0].callback && v(i[0].callback, !1), !t)
+        for (let r = 0, o = i.length; r < o; ++r) {
+          const l = i[r];
+          if (!l.complete) {
+            t = l.anchor;
+            break;
+          }
+        }
+    }
+    this.animations_.length = 0, this.cancelAnchor_ = t, this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
+  }
+  /**
+   * Update all animations.
+   */
+  updateAnimations_() {
+    if (this.updateAnimationKey_ !== void 0 && (cancelAnimationFrame(this.updateAnimationKey_), this.updateAnimationKey_ = void 0), !this.getAnimating())
+      return;
+    const t = Date.now();
+    let e = !1;
+    for (let n = this.animations_.length - 1; n >= 0; --n) {
+      const i = this.animations_[n];
+      let r = !0;
+      for (let o = 0, l = i.length; o < l; ++o) {
+        const a = i[o];
+        if (a.complete)
+          continue;
+        const c = t - a.start;
+        let h = a.duration > 0 ? c / a.duration : 1;
+        h >= 1 ? (a.complete = !0, h = 1) : r = !1;
+        const u = a.easing(h);
+        if (a.sourceCenter) {
+          const g = a.sourceCenter[0], d = a.sourceCenter[1], f = a.targetCenter[0], R = a.targetCenter[1];
+          this.nextCenter_ = a.targetCenter;
+          const _ = g + u * (f - g), C = d + u * (R - d);
+          this.targetCenter_ = [_, C];
+        }
+        if (a.sourceResolution && a.targetResolution) {
+          const g = u === 1 ? a.targetResolution : a.sourceResolution + u * (a.targetResolution - a.sourceResolution);
+          if (a.anchor) {
+            const d = this.getViewportSize_(this.getRotation()), f = this.constraints_.resolution(
+              g,
+              0,
+              d,
+              !0
+            );
+            this.targetCenter_ = this.calculateCenterZoom(
+              f,
+              a.anchor
+            );
+          }
+          this.nextResolution_ = a.targetResolution, this.targetResolution_ = g, this.applyTargetState_(!0);
+        }
+        if (a.sourceRotation !== void 0 && a.targetRotation !== void 0) {
+          const g = u === 1 ? W(a.targetRotation + Math.PI, 2 * Math.PI) - Math.PI : a.sourceRotation + u * (a.targetRotation - a.sourceRotation);
+          if (a.anchor) {
+            const d = this.constraints_.rotation(
+              g,
+              !0
+            );
+            this.targetCenter_ = this.calculateCenterRotate(
+              d,
+              a.anchor
+            );
+          }
+          this.nextRotation_ = a.targetRotation, this.targetRotation_ = g;
+        }
+        if (this.applyTargetState_(!0), e = !0, !a.complete)
+          break;
+      }
+      if (r) {
+        this.animations_[n] = null, this.setHint(I.ANIMATING, -1), this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
+        const o = i[0].callback;
+        o && v(o, !0);
+      }
+    }
+    this.animations_ = this.animations_.filter(Boolean), e && this.updateAnimationKey_ === void 0 && (this.updateAnimationKey_ = requestAnimationFrame(
+      this.updateAnimations_.bind(this)
+    ));
+  }
+  /**
+   * @param {number} rotation Target rotation.
+   * @param {import("./coordinate.js").Coordinate} anchor Rotation anchor.
+   * @return {import("./coordinate.js").Coordinate|undefined} Center for rotation and anchor.
+   */
+  calculateCenterRotate(t, e) {
+    let n;
+    const i = this.getCenterInternal();
+    return i !== void 0 && (n = [i[0] - e[0], i[1] - e[1]], Ot(n, t - this.getRotation()), Vt(n, e)), n;
+  }
+  /**
+   * @param {number} resolution Target resolution.
+   * @param {import("./coordinate.js").Coordinate} anchor Zoom anchor.
+   * @return {import("./coordinate.js").Coordinate|undefined} Center for resolution and anchor.
+   */
+  calculateCenterZoom(t, e) {
+    let n;
+    const i = this.getCenterInternal(), r = this.getResolution();
+    if (i !== void 0 && r !== void 0) {
+      const o = e[0] - t * (e[0] - i[0]) / r, l = e[1] - t * (e[1] - i[1]) / r;
+      n = [o, l];
+    }
+    return n;
+  }
+  /**
+   * Returns the current viewport size.
+   * @private
+   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
+   * @return {import("./size.js").Size} Viewport size or `[100, 100]` when no viewport is found.
+   */
+  getViewportSize_(t) {
+    const e = this.viewportSize_;
+    if (t) {
+      const n = e[0], i = e[1];
+      return [
+        Math.abs(n * Math.cos(t)) + Math.abs(i * Math.sin(t)),
+        Math.abs(n * Math.sin(t)) + Math.abs(i * Math.cos(t))
+      ];
+    }
+    return e;
+  }
+  /**
+   * Stores the viewport size on the view. The viewport size is not read every time from the DOM
+   * to avoid performance hit and layout reflow.
+   * This should be done on map size change.
+   * Note: the constraints are not resolved during an animation to avoid stopping it
+   * @param {import("./size.js").Size} [size] Viewport size; if undefined, [100, 100] is assumed
+   */
+  setViewportSize(t) {
+    this.viewportSize_ = Array.isArray(t) ? t.slice() : [100, 100], this.getAnimating() || this.resolveConstraints(0);
+  }
+  /**
+   * Get the view center.
+   * @return {import("./coordinate.js").Coordinate|undefined} The center of the view.
+   * @observable
+   * @api
+   */
+  getCenter() {
+    const t = this.getCenterInternal();
+    return t && K(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(M.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 box size.
+   * @param {import("./size.js").Size} [size] The pixel dimensions of the box
+   * into which the calculated extent should fit. Defaults to the size of the
+   * map the view is associated with.
+   * If no map or multiple maps are connected to the view, provide the desired
+   * box size (e.g. `map.getSize()`).
+   * @return {import("./extent.js").Extent} Extent.
+   * @api
+   */
+  calculateExtent(t) {
+    const e = this.calculateExtentInternal(t);
+    return kt(e, this.getProjection());
+  }
+  /**
+   * @param {import("./size.js").Size} [size] Box pixel size. If not provided,
+   * the map's last known viewport size will be used.
+   * @return {import("./extent.js").Extent} Extent.
+   */
+  calculateExtentInternal(t) {
+    t = t || this.getViewportSizeMinusPadding_();
+    const e = (
+      /** @type {!import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    N(e, "The view center is not defined");
+    const n = (
+      /** @type {!number} */
+      this.getResolution()
+    );
+    N(n !== void 0, "The view resolution is not defined");
+    const i = (
+      /** @type {!number} */
+      this.getRotation()
+    );
+    return N(i !== void 0, "The view rotation is not defined"), Ut(e, n, i, 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(M.RESOLUTION)
+    );
+  }
+  /**
+   * Get the resolutions for the view. This returns the array of resolutions
+   * passed to the constructor of the View, or undefined if none were given.
+   * @return {Array<number>|undefined} The resolutions of the view.
+   * @api
+   */
+  getResolutions() {
+    return this.resolutions_;
+  }
+  /**
+   * Get the resolution for a provided extent (in map units) and size (in pixels).
+   * @param {import("./extent.js").Extent} extent Extent.
+   * @param {import("./size.js").Size} [size] Box pixel size.
+   * @return {number} The resolution at which the provided extent will render at
+   *     the given size.
+   * @api
+   */
+  getResolutionForExtent(t, e) {
+    return this.getResolutionForExtentInternal(
+      E(t, this.getProjection()),
+      e
+    );
+  }
+  /**
+   * Get the resolution for a provided extent (in map units) and size (in pixels).
+   * @param {import("./extent.js").Extent} extent Extent.
+   * @param {import("./size.js").Size} [size] Box pixel size.
+   * @return {number} The resolution at which the provided extent will render at
+   *     the given size.
+   */
+  getResolutionForExtentInternal(t, e) {
+    e = e || this.getViewportSizeMinusPadding_();
+    const n = G(t) / e[0], i = F(t) / e[1];
+    return Math.max(n, i);
+  }
+  /**
+   * Return a function that returns a value between 0 and 1 for a
+   * resolution. Exponential scaling is assumed.
+   * @param {number} [power] Power.
+   * @return {function(number): number} Resolution for value function.
+   */
+  getResolutionForValueFunction(t) {
+    t = t || 2;
+    const e = this.getConstrainedResolution(this.maxResolution_), n = this.minResolution_, i = Math.log(e / n) / Math.log(t);
+    return (
+      /**
+       * @param {number} value Value.
+       * @return {number} Resolution.
+       */
+      (function(r) {
+        return e / Math.pow(t, r * i);
+      })
+    );
+  }
+  /**
+   * Get the view rotation.
+   * @return {number} The rotation of the view in radians.
+   * @observable
+   * @api
+   */
+  getRotation() {
+    return (
+      /** @type {number} */
+      this.get(M.ROTATION)
+    );
+  }
+  /**
+   * Return a function that returns a resolution for a value between
+   * 0 and 1. Exponential scaling is assumed.
+   * @param {number} [power] Power.
+   * @return {function(number): number} Value for resolution function.
+   */
+  getValueForResolutionFunction(t) {
+    const e = Math.log(t || 2), n = this.getConstrainedResolution(this.maxResolution_), i = this.minResolution_, r = Math.log(n / i) / e;
+    return (
+      /**
+       * @param {number} resolution Resolution.
+       * @return {number} Value.
+       */
+      (function(o) {
+        return Math.log(n / o) / e / 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 e = this.getViewportSize_(t);
+    const n = this.padding_;
+    return n && (e = [
+      e[0] - n[1] - n[3],
+      e[1] - n[0] - n[2]
+    ]), e;
+  }
+  /**
+   * @return {State} View state.
+   */
+  getState() {
+    const t = this.getProjection(), e = this.getResolution(), n = this.getRotation();
+    let i = (
+      /** @type {import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    const r = this.padding_;
+    if (r) {
+      const o = this.getViewportSizeMinusPadding_();
+      i = X(
+        i,
+        this.getViewportSize_(),
+        [o[0] / 2 + r[3], o[1] / 2 + r[0]],
+        e,
+        n
+      );
+    }
+    return {
+      center: i.slice(0),
+      projection: t !== void 0 ? t : null,
+      resolution: e,
+      nextCenter: this.nextCenter_,
+      nextResolution: this.nextResolution_,
+      nextRotation: this.nextRotation_,
+      rotation: n,
+      zoom: this.getZoom()
+    };
+  }
+  /**
+   * @return {ViewStateLayerStateExtent} Like `FrameState`, but just `viewState` and `extent`.
+   */
+  getViewStateAndExtent() {
+    return {
+      viewState: this.getState(),
+      extent: this.calculateExtent()
+    };
+  }
+  /**
+   * Get the current zoom level. This method may return non-integer zoom levels
+   * if the view does not constrain the resolution, or if an interaction or
+   * animation is underway.
+   * @return {number|undefined} Zoom.
+   * @api
+   */
+  getZoom() {
+    let t;
+    const e = this.getResolution();
+    return e !== void 0 && (t = this.getZoomForResolution(e)), t;
+  }
+  /**
+   * Get the zoom level for a resolution.
+   * @param {number} resolution The resolution.
+   * @return {number|undefined} The zoom level for the provided resolution.
+   * @api
+   */
+  getZoomForResolution(t) {
+    let e = this.minZoom_ || 0, n, i;
+    if (this.resolutions_) {
+      const r = rt(this.resolutions_, t, 1);
+      e = r, n = this.resolutions_[r], r == this.resolutions_.length - 1 ? i = 2 : i = n / this.resolutions_[r + 1];
+    } else
+      n = this.maxResolution_, i = this.zoomFactor_;
+    return e + Math.log(n / t) / Math.log(i);
+  }
+  /**
+   * 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_?.length) {
+      if (this.resolutions_.length === 1)
+        return this.resolutions_[0];
+      const e = p(
+        Math.floor(t),
+        0,
+        this.resolutions_.length - 2
+      ), n = this.resolutions_[e] / this.resolutions_[e + 1];
+      return this.resolutions_[e] / Math.pow(n, p(t - e, 0, 1));
+    }
+    return this.maxResolution_ / Math.pow(this.zoomFactor_, t - this.minZoom_);
+  }
+  /**
+   * Fit the given geometry or extent based on the given map size and border.
+   * The size is pixel dimensions of the box to fit the extent into.
+   * In most cases you will want to use the map size, that is `map.getSize()`.
+   * Takes care of the map angle.
+   * @param {import("./geom/SimpleGeometry.js").default|import("./extent.js").Extent} geometryOrExtent The geometry or
+   *     extent to fit the view to.
+   * @param {FitOptions} [options] Options.
+   * @api
+   */
+  fit(t, e) {
+    let n;
+    if (N(
+      Array.isArray(t) || typeof /** @type {?} */
+      t.getSimplifiedGeometry == "function",
+      "Invalid extent or geometry provided as `geometry`"
+    ), Array.isArray(t)) {
+      N(
+        !ot(t),
+        "Cannot fit empty extent provided as `geometry`"
+      );
+      const i = E(t, this.getProjection());
+      n = tt(i);
+    } else if (t.getType() === "Circle") {
+      const i = E(
+        t.getExtent(),
+        this.getProjection()
+      );
+      n = tt(i), n.rotate(this.getRotation(), S(i));
+    } else
+      n = t;
+    this.fitInternal(n, e);
+  }
+  /**
+   * Calculate rotated extent
+   * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
+   * @return {import("./extent").Extent} The rotated extent for the geometry.
+   */
+  rotatedExtentForGeometry(t) {
+    const e = this.getRotation(), n = Math.cos(e), i = Math.sin(-e), r = t.getFlatCoordinates(), o = t.getStride();
+    let l = 1 / 0, a = 1 / 0, c = -1 / 0, h = -1 / 0;
+    for (let u = 0, g = r.length; u < g; u += o) {
+      const d = r[u] * n - r[u + 1] * i, f = r[u] * i + r[u + 1] * n;
+      l = Math.min(l, d), a = Math.min(a, f), c = Math.max(c, d), h = Math.max(h, f);
+    }
+    return [l, a, c, h];
+  }
+  /**
+   * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
+   * @param {FitOptions} [options] Options.
+   */
+  fitInternal(t, e) {
+    e = e || {};
+    let n = e.size;
+    n || (n = this.getViewportSizeMinusPadding_());
+    const i = e.padding !== void 0 ? e.padding : [0, 0, 0, 0], r = e.nearest !== void 0 ? e.nearest : !1;
+    let o;
+    e.minResolution !== void 0 ? o = e.minResolution : e.maxZoom !== void 0 ? o = this.getResolutionForZoom(e.maxZoom) : o = 0;
+    const l = this.rotatedExtentForGeometry(t);
+    let a = this.getResolutionForExtentInternal(l, [
+      n[0] - i[1] - i[3],
+      n[1] - i[0] - i[2]
+    ]);
+    a = isNaN(a) ? o : Math.max(a, o), a = this.getConstrainedResolution(a, r ? 0 : 1);
+    const c = this.getRotation(), h = Math.sin(c), u = Math.cos(c), g = S(l);
+    g[0] += (i[1] - i[3]) / 2 * a, g[1] += (i[0] - i[2]) / 2 * a;
+    const d = g[0] * u - g[1] * h, f = g[1] * u + g[0] * h, R = this.getConstrainedCenter([d, f], a), _ = e.callback ? e.callback : Dt;
+    e.duration !== void 0 ? this.animateInternal(
+      {
+        resolution: a,
+        center: R,
+        duration: e.duration,
+        easing: e.easing
+      },
+      _
+    ) : (this.targetResolution_ = a, this.targetCenter_ = R, this.applyTargetState_(!1, !0), v(_, !0));
+  }
+  /**
+   * Center on coordinate and view position.
+   * @param {import("./coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("./size.js").Size} size Box pixel size.
+   * @param {import("./pixel.js").Pixel} position Position on the view to center on.
+   * @api
+   */
+  centerOn(t, e, n) {
+    this.centerOnInternal(
+      y(t, this.getProjection()),
+      e,
+      n
+    );
+  }
+  /**
+   * @param {import("./coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("./size.js").Size} size Box pixel size.
+   * @param {import("./pixel.js").Pixel} position Position on the view to center on.
+   */
+  centerOnInternal(t, e, n) {
+    this.setCenterInternal(
+      X(
+        t,
+        e,
+        n,
+        this.getResolution(),
+        this.getRotation()
+      )
+    );
+  }
+  /**
+   * Calculates the shift between map and viewport center.
+   * @param {import("./coordinate.js").Coordinate} center Center.
+   * @param {number} resolution Resolution.
+   * @param {number} rotation Rotation.
+   * @param {import("./size.js").Size} size Size.
+   * @return {Array<number>|undefined} Center shift.
+   */
+  calculateCenterShift(t, e, n, i) {
+    let r;
+    const o = this.padding_;
+    if (o && t) {
+      const l = this.getViewportSizeMinusPadding_(-n), a = X(
+        t,
+        i,
+        [l[0] / 2 + o[3], l[1] / 2 + o[0]],
+        e,
+        n
+      );
+      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 e = K(this.targetCenter_, this.getProjection());
+    this.setCenter([
+      e[0] + t[0],
+      e[1] + t[1]
+    ]);
+  }
+  /**
+   * Adds relative coordinates to the center of the view. Any extent constraint will apply.
+   * @param {import("./coordinate.js").Coordinate} deltaCoordinates Relative value to add.
+   */
+  adjustCenterInternal(t) {
+    const e = this.targetCenter_;
+    this.setCenterInternal([
+      e[0] + t[0],
+      e[1] + t[1]
+    ]);
+  }
+  /**
+   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
+   * constraint will apply.
+   * @param {number} ratio The ratio to apply on the view resolution.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   * @api
+   */
+  adjustResolution(t, e) {
+    e = e && y(e, this.getProjection()), this.adjustResolutionInternal(t, e);
+  }
+  /**
+   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
+   * constraint will apply.
+   * @param {number} ratio The ratio to apply on the view resolution.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   */
+  adjustResolutionInternal(t, e) {
+    const n = this.getAnimating() || this.getInteracting(), i = this.getViewportSize_(this.getRotation()), r = this.constraints_.resolution(
+      this.targetResolution_ * t,
+      0,
+      i,
+      n
+    );
+    e && (this.targetCenter_ = this.calculateCenterZoom(r, e)), this.targetResolution_ *= t, this.applyTargetState_();
+  }
+  /**
+   * Adds a value to the view zoom level, optionally using an anchor. Any resolution
+   * constraint will apply.
+   * @param {number} delta Relative value to add to the zoom level.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   * @api
+   */
+  adjustZoom(t, e) {
+    this.adjustResolution(Math.pow(this.zoomFactor_, -t), e);
+  }
+  /**
+   * Adds a value to the view rotation, optionally using an anchor. Any rotation
+   * constraint will apply.
+   * @param {number} delta Relative value to add to the zoom rotation, in radians.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
+   * @api
+   */
+  adjustRotation(t, e) {
+    e && (e = y(e, this.getProjection())), this.adjustRotationInternal(t, e);
+  }
+  /**
+   * @param {number} delta Relative value to add to the zoom rotation, in radians.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
+   */
+  adjustRotationInternal(t, e) {
+    const n = this.getAnimating() || this.getInteracting(), i = this.constraints_.rotation(
+      this.targetRotation_ + t,
+      n
+    );
+    e && (this.targetCenter_ = this.calculateCenterRotate(i, e)), this.targetRotation_ += t, this.applyTargetState_();
+  }
+  /**
+   * Set the center of the current view. Any extent constraint will apply.
+   * @param {import("./coordinate.js").Coordinate|undefined} center The center of the view.
+   * @observable
+   * @api
+   */
+  setCenter(t) {
+    this.setCenterInternal(
+      t && y(t, this.getProjection())
+    );
+  }
+  /**
+   * Set the center using the view projection (not the user projection).
+   * @param {import("./coordinate.js").Coordinate|undefined} center The center of the view.
+   */
+  setCenterInternal(t) {
+    this.targetCenter_ = t, this.applyTargetState_();
+  }
+  /**
+   * @param {import("./ViewHint.js").default} hint Hint.
+   * @param {number} delta Delta.
+   * @return {number} New value.
+   */
+  setHint(t, e) {
+    return this.hints_[t] += e, this.changed(), this.hints_[t];
+  }
+  /**
+   * Set the resolution for this view. Any resolution constraint will apply.
+   * @param {number|undefined} resolution The resolution of the view.
+   * @observable
+   * @api
+   */
+  setResolution(t) {
+    this.targetResolution_ = t, this.applyTargetState_();
+  }
+  /**
+   * Set the rotation for this view. Any rotation constraint will apply.
+   * @param {number} rotation The rotation of the view in radians.
+   * @observable
+   * @api
+   */
+  setRotation(t) {
+    this.targetRotation_ = t, this.applyTargetState_();
+  }
+  /**
+   * Zoom to a specific zoom level. Any resolution constrain will apply.
+   * @param {number} zoom Zoom level.
+   * @api
+   */
+  setZoom(t) {
+    this.setResolution(this.getResolutionForZoom(t));
+  }
+  /**
+   * Recompute rotation/resolution/center based on target values.
+   * Note: we have to compute rotation first, then resolution and center considering that
+   * parameters can influence one another in case a view extent constraint is present.
+   * @param {boolean} [doNotCancelAnims] Do not cancel animations.
+   * @param {boolean} [forceMoving] Apply constraints as if the view is moving.
+   * @private
+   */
+  applyTargetState_(t, e) {
+    const n = this.getAnimating() || this.getInteracting() || e, i = this.constraints_.rotation(
+      this.targetRotation_,
+      n
+    ), r = this.getViewportSize_(i), o = this.constraints_.resolution(
+      this.targetResolution_,
+      0,
+      r,
+      n
+    ), l = this.constraints_.center(
+      this.targetCenter_,
+      o,
+      r,
+      n,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        o,
+        i,
+        r
+      )
+    );
+    this.get(M.ROTATION) !== i && this.set(M.ROTATION, i), this.get(M.RESOLUTION) !== o && (this.set(M.RESOLUTION, o), this.set("zoom", this.getZoom(), !0)), (!l || !this.get(M.CENTER) || !Y(this.get(M.CENTER), l)) && this.set(M.CENTER, l), this.getAnimating() && !t && this.cancelAnimations(), this.cancelAnchor_ = void 0;
+  }
+  /**
+   * If any constraints need to be applied, an animation will be triggered.
+   * This is typically done on interaction end.
+   * Note: calling this with a duration of 0 will apply the constrained values straight away,
+   * without animation.
+   * @param {number} [duration] The animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   */
+  resolveConstraints(t, e, n) {
+    t = t !== void 0 ? t : 200;
+    const i = e || 0, r = this.constraints_.rotation(this.targetRotation_), o = this.getViewportSize_(r), l = this.constraints_.resolution(
+      this.targetResolution_,
+      i,
+      o
+    ), a = this.constraints_.center(
+      this.targetCenter_,
+      l,
+      o,
+      !1,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        l,
+        r,
+        o
+      )
+    );
+    if (t === 0 && !this.cancelAnchor_) {
+      this.targetResolution_ = l, this.targetRotation_ = r, this.targetCenter_ = a, this.applyTargetState_();
+      return;
+    }
+    n = n || (t === 0 ? this.cancelAnchor_ : void 0), this.cancelAnchor_ = void 0, (this.getResolution() !== l || this.getRotation() !== r || !this.getCenterInternal() || !Y(this.getCenterInternal(), a)) && (this.getAnimating() && this.cancelAnimations(), this.animateInternal({
+      rotation: r,
+      center: a,
+      resolution: l,
+      duration: t,
+      easing: Bt,
+      anchor: n
+    }));
+  }
+  /**
+   * 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(I.INTERACTING, 1);
+  }
+  /**
+   * Notify the View that an interaction has ended. The view state will be resolved
+   * to a stable one if needed (depending on its constraints).
+   * @param {number} [duration] Animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   * @api
+   */
+  endInteraction(t, e, n) {
+    n = n && y(n, this.getProjection()), this.endInteractionInternal(t, e, n);
+  }
+  /**
+   * Notify the View that an interaction has ended. The view state will be resolved
+   * to a stable one if needed (depending on its constraints).
+   * @param {number} [duration] Animation duration in ms.
+   * @param {number} [resolutionDirection] Which direction to zoom.
+   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
+   */
+  endInteractionInternal(t, e, n) {
+    this.getInteracting() && (this.setHint(I.INTERACTING, -1), this.resolveConstraints(t, e, n));
+  }
+  /**
+   * Get a valid position for the view center according to the current constraints.
+   * @param {import("./coordinate.js").Coordinate|undefined} targetCenter Target center position.
+   * @param {number} [targetResolution] Target resolution. If not supplied, the current one will be used.
+   * This is useful to guess a valid center position at a different zoom level.
+   * @return {import("./coordinate.js").Coordinate|undefined} Valid center position.
+   */
+  getConstrainedCenter(t, e) {
+    const n = this.getViewportSize_(this.getRotation());
+    return this.constraints_.center(
+      t,
+      e || this.getResolution(),
+      n
+    );
+  }
+  /**
+   * Get a valid zoom level according to the current view constraints.
+   * @param {number|undefined} targetZoom Target zoom.
+   * @param {number} [direction] Indicate which resolution should be used
+   * by a renderer if the view resolution does not match any resolution of the tile source.
+   * If 0, the nearest resolution will be used. If 1, the nearest lower resolution
+   * will be used. If -1, the nearest higher resolution will be used.
+   * @return {number|undefined} Valid zoom level.
+   */
+  getConstrainedZoom(t, e) {
+    const n = this.getResolutionForZoom(t);
+    return this.getZoomForResolution(
+      this.getConstrainedResolution(n, e)
+    );
+  }
+  /**
+   * Get a valid resolution according to the current view constraints.
+   * @param {number|undefined} targetResolution Target resolution.
+   * @param {number} [direction] Indicate which resolution should be used
+   * by a renderer if the view resolution does not match any resolution of the tile source.
+   * If 0, the nearest resolution will be used. If 1, the nearest lower resolution
+   * will be used. If -1, the nearest higher resolution will be used.
+   * @return {number|undefined} Valid resolution.
+   */
+  getConstrainedResolution(t, e) {
+    e = e || 0;
+    const n = this.getViewportSize_(this.getRotation());
+    return this.constraints_.resolution(t, e, n);
+  }
+}
+function v(s, t) {
+  setTimeout(function() {
+    s(t);
+  }, 0);
+}
+function It(s) {
+  if (s.extent !== void 0) {
+    const e = s.smoothExtentConstraint !== void 0 ? s.smoothExtentConstraint : !0;
+    return $(s.extent, s.constrainOnlyCenter, e);
+  }
+  const t = L(s.projection, "EPSG:3857");
+  if (s.multiWorld !== !0 && t.isGlobal()) {
+    const e = t.getExtent().slice();
+    return e[0] = -1 / 0, e[2] = 1 / 0, $(e, !1, !1);
+  }
+  return Qt;
+}
+function At(s) {
+  let t, e, n, o = s.minZoom !== void 0 ? s.minZoom : P, l = s.maxZoom !== void 0 ? s.maxZoom : 28;
+  const a = s.zoomFactor !== void 0 ? s.zoomFactor : 2, c = s.multiWorld !== void 0 ? s.multiWorld : !1, h = s.smoothResolutionConstraint !== void 0 ? s.smoothResolutionConstraint : !0, u = s.showFullExtent !== void 0 ? s.showFullExtent : !1, g = L(s.projection, "EPSG:3857"), d = g.getExtent();
+  let f = s.constrainOnlyCenter, R = s.extent;
+  if (!c && !R && g.isGlobal() && (f = !1, R = d), s.resolutions !== void 0) {
+    const _ = s.resolutions;
+    e = _[o], n = _[l] !== void 0 ? _[l] : _[_.length - 1], s.constrainResolution ? t = he(
+      _,
+      h,
+      !f && R,
+      u
+    ) : t = et(
+      e,
+      n,
+      h,
+      !f && R,
+      u
+    );
+  } else {
+    const C = (d ? Math.max(G(d), F(d)) : (
+      // use an extent that can fit the whole world if need be
+      360 * Lt.degrees / g.getMetersPerUnit()
+    )) / Jt / Math.pow(2, P), m = C / Math.pow(2, 28 - P);
+    e = s.maxResolution, e !== void 0 ? o = 0 : e = C / Math.pow(a, o), n = s.minResolution, n === void 0 && (s.maxZoom !== void 0 ? s.maxResolution !== void 0 ? n = e / Math.pow(a, l) : n = C / Math.pow(a, l) : n = m), l = o + Math.floor(
+      Math.log(e / n) / Math.log(a)
+    ), n = e / Math.pow(a, l - o), s.constrainResolution ? t = ue(
+      a,
+      e,
+      n,
+      h,
+      !f && R,
+      u
+    ) : t = et(
+      e,
+      n,
+      h,
+      !f && R,
+      u
+    );
+  }
+  return {
+    constraint: t,
+    maxResolution: e,
+    minResolution: n,
+    minZoom: o,
+    zoomFactor: a
+  };
+}
+function wt(s) {
+  if (s.enableRotation !== void 0 ? s.enableRotation : !0) {
+    const e = s.constrainRotation;
+    return e === void 0 || e === !0 ? de() : e === !1 ? nt : typeof e == "number" ? ge(e) : nt;
+  }
+  return ce;
+}
+function Nt(s) {
+  return !(s.sourceCenter && s.targetCenter && !Y(s.sourceCenter, s.targetCenter) || s.sourceResolution !== s.targetResolution || s.sourceRotation !== s.targetRotation);
+}
+function X(s, t, e, n, i) {
+  const r = Math.cos(-i);
+  let o = Math.sin(-i), l = s[0] * r - s[1] * o, a = s[1] * r + s[0] * o;
+  l += (t[0] / 2 - e[0]) * n, a += (e[1] - t[1] / 2) * n, o = -o;
+  const c = l * r - a * o, h = a * r + l * o;
+  return [c, h];
+}
+const Te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createCenterConstraint: It,
+  createResolutionConstraint: At,
+  createRotationConstraint: wt,
+  default: fe,
+  isNoopAnimation: Nt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  A,
+  me as B,
+  J as C,
+  yt as D,
+  b as E,
+  oe as F,
+  se as G,
+  fe as H,
+  M as I,
+  tt as J,
+  ce as K,
+  T as L,
+  Te as M,
+  V as P,
+  O as S,
+  I as V,
+  dt as a,
+  xt as b,
+  Rt as c,
+  re as d,
+  gt as e,
+  ft as f,
+  Ct as g,
+  Ie as h,
+  mt as i,
+  _t as j,
+  xe as k,
+  Me as l,
+  ct as m,
+  Ce as n,
+  je as o,
+  ye as p,
+  we as q,
+  te as r,
+  Ne as s,
+  Ae as t,
+  Z as u,
+  pe as v,
+  pt as w,
+  Fe as x,
+  lt as y,
+  Mt as z
+};