@swissgeo/coordinates 1.0.0-rc.1 → 1.0.1

package/dist/ol.js

@@ -0,0 +1,4467 @@
+import { v as Oe, L as P, E as _t } from "./registerProj4-CwR_kPOz.js";
+const Le = {
+  /**
+   * Triggered when a property is changed.
+   * @event module:ol/Object.ObjectEvent#propertychange
+   * @api
+   */
+  PROPERTYCHANGE: "propertychange"
+}, be = {
+  /**
+   * Generic change event. Triggered when the revision counter is increased.
+   * @event module:ol/events/Event~BaseEvent#change
+   * @api
+   */
+  CHANGE: "change"
+};
+class Ue {
+  constructor() {
+    this.disposed = !1;
+  }
+  /**
+   * Clean up.
+   */
+  dispose() {
+    this.disposed || (this.disposed = !0, this.disposeInternal());
+  }
+  /**
+   * Extension point for disposable objects.
+   * @protected
+   */
+  disposeInternal() {
+  }
+}
+function le(i, t) {
+  return i > t ? 1 : i < t ? -1 : 0;
+}
+function wt(i, t, e) {
+  if (i[0] <= t)
+    return 0;
+  const n = i.length;
+  if (t <= i[n - 1])
+    return n - 1;
+  if (typeof e == "function") {
+    for (let s = 1; s < n; ++s) {
+      const r = i[s];
+      if (r === t)
+        return s;
+      if (r < t)
+        return e(t, i[s - 1], r) > 0 ? s - 1 : s;
+    }
+    return n - 1;
+  }
+  if (e > 0) {
+    for (let s = 1; s < n; ++s)
+      if (i[s] < t)
+        return s - 1;
+    return n - 1;
+  }
+  if (e < 0) {
+    for (let s = 1; s < n; ++s)
+      if (i[s] <= t)
+        return s;
+    return n - 1;
+  }
+  for (let s = 1; s < n; ++s) {
+    if (i[s] == t)
+      return s;
+    if (i[s] < t)
+      return i[s - 1] - t < t - i[s] ? s - 1 : s;
+  }
+  return n - 1;
+}
+function Ve(i, t) {
+  const e = Array.isArray(t) ? t : [t], n = e.length;
+  for (let s = 0; s < n; s++)
+    i[i.length] = e[s];
+}
+function De(i, t) {
+  const e = i.length;
+  if (e !== t.length)
+    return !1;
+  for (let n = 0; n < e; n++)
+    if (i[n] !== t[n])
+      return !1;
+  return !0;
+}
+function We(i, t, e) {
+  const n = t || le;
+  return i.every(function(s, r) {
+    if (r === 0)
+      return !0;
+    const o = n(i[r - 1], s);
+    return !(o > 0 || o === 0);
+  });
+}
+function Ct() {
+}
+function $e(i) {
+  let t, e, n;
+  return function() {
+    const s = Array.prototype.slice.call(arguments);
+    return (!e || this !== n || !De(s, e)) && (n = this, e = s, t = i.apply(this, arguments)), t;
+  };
+}
+function ue(i) {
+  for (const t in i)
+    delete i[t];
+}
+function He(i) {
+  let t;
+  for (t in i)
+    return !1;
+  return !t;
+}
+class he {
+  /**
+   * @param {string} type Type.
+   */
+  constructor(t) {
+    this.propagationStopped, this.defaultPrevented, this.type = t, this.target = null;
+  }
+  /**
+   * Prevent default. This means that no emulated `click`, `singleclick` or `doubleclick` events
+   * will be fired.
+   * @api
+   */
+  preventDefault() {
+    this.defaultPrevented = !0;
+  }
+  /**
+   * Stop event propagation.
+   * @api
+   */
+  stopPropagation() {
+    this.propagationStopped = !0;
+  }
+}
+class ke extends Ue {
+  /**
+   * @param {*} [target] Default event target for dispatched events.
+   */
+  constructor(t) {
+    super(), this.eventTarget_ = t, this.pendingRemovals_ = null, this.dispatching_ = null, this.listeners_ = null;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  addEventListener(t, e) {
+    if (!t || !e)
+      return;
+    const n = this.listeners_ || (this.listeners_ = {}), s = n[t] || (n[t] = []);
+    s.includes(e) || s.push(e);
+  }
+  /**
+   * Dispatches an event and calls all listeners listening for events
+   * of this type. The event parameter can either be a string or an
+   * Object with a `type` property.
+   *
+   * @param {import("./Event.js").default|string} event Event object.
+   * @return {boolean|undefined} `false` if anyone called preventDefault on the
+   *     event object or if any of the listeners returned false.
+   * @api
+   */
+  dispatchEvent(t) {
+    const e = typeof t == "string", n = e ? t : t.type, s = this.listeners_ && this.listeners_[n];
+    if (!s)
+      return;
+    const r = e ? new he(t) : (
+      /** @type {Event} */
+      t
+    );
+    r.target || (r.target = this.eventTarget_ || this);
+    const o = this.dispatching_ || (this.dispatching_ = {}), a = this.pendingRemovals_ || (this.pendingRemovals_ = {});
+    n in o || (o[n] = 0, a[n] = 0), ++o[n];
+    let l;
+    for (let h = 0, u = s.length; h < u; ++h)
+      if ("handleEvent" in s[h] ? l = /** @type {import("../events.js").ListenerObject} */
+      s[h].handleEvent(r) : l = /** @type {import("../events.js").ListenerFunction} */
+      s[h].call(this, r), l === !1 || r.propagationStopped) {
+        l = !1;
+        break;
+      }
+    if (--o[n] === 0) {
+      let h = a[n];
+      for (delete a[n]; h--; )
+        this.removeEventListener(n, Ct);
+      delete o[n];
+    }
+    return l;
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.listeners_ && ue(this.listeners_);
+  }
+  /**
+   * Get the listeners for a specified event type. Listeners are returned in the
+   * order that they will be called in.
+   *
+   * @param {string} type Type.
+   * @return {Array<import("../events.js").Listener>|undefined} Listeners.
+   */
+  getListeners(t) {
+    return this.listeners_ && this.listeners_[t] || void 0;
+  }
+  /**
+   * @param {string} [type] Type. If not provided,
+   *     `true` will be returned if this event target has any listeners.
+   * @return {boolean} Has listeners.
+   */
+  hasListener(t) {
+    return this.listeners_ ? t ? t in this.listeners_ : Object.keys(this.listeners_).length > 0 : !1;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  removeEventListener(t, e) {
+    if (!this.listeners_)
+      return;
+    const n = this.listeners_[t];
+    if (!n)
+      return;
+    const s = n.indexOf(e);
+    s !== -1 && (this.pendingRemovals_ && t in this.pendingRemovals_ ? (n[s] = Ct, ++this.pendingRemovals_[t]) : (n.splice(s, 1), n.length === 0 && delete this.listeners_[t]));
+  }
+}
+function Et(i, t, e, n, s) {
+  if (s) {
+    const o = e;
+    e = function(a) {
+      return i.removeEventListener(t, e), o.call(this, a);
+    };
+  }
+  const r = {
+    target: i,
+    type: t,
+    listener: e
+  };
+  return i.addEventListener(t, e), r;
+}
+function jt(i, t, e, n) {
+  return Et(i, t, e, n, !0);
+}
+function zt(i) {
+  i && i.target && (i.target.removeEventListener(i.type, i.listener), ue(i));
+}
+class qe extends ke {
+  constructor() {
+    super(), this.on = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onInternal, this.once = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onceInternal, this.un = /** @type {ObservableOnSignature<void>} */
+    this.unInternal, this.revision_ = 0;
+  }
+  /**
+   * Increases the revision counter and dispatches a 'change' event.
+   * @api
+   */
+  changed() {
+    ++this.revision_, this.dispatchEvent(be.CHANGE);
+  }
+  /**
+   * Get the version number for this object.  Each time the object is modified,
+   * its version number will be incremented.
+   * @return {number} Revision.
+   * @api
+   */
+  getRevision() {
+    return this.revision_;
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onInternal(t, e) {
+    if (Array.isArray(t)) {
+      const n = t.length, s = new Array(n);
+      for (let r = 0; r < n; ++r)
+        s[r] = Et(this, t[r], e);
+      return s;
+    }
+    return Et(
+      this,
+      /** @type {string} */
+      t,
+      e
+    );
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onceInternal(t, e) {
+    let n;
+    if (Array.isArray(t)) {
+      const s = t.length;
+      n = new Array(s);
+      for (let r = 0; r < s; ++r)
+        n[r] = jt(this, t[r], e);
+    } else
+      n = jt(
+        this,
+        /** @type {string} */
+        t,
+        e
+      );
+    return e.ol_key = n, n;
+  }
+  /**
+   * Unlisten for a certain type of event.
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @protected
+   */
+  unInternal(t, e) {
+    const n = (
+      /** @type {Object} */
+      e.ol_key
+    );
+    if (n)
+      Be(n);
+    else if (Array.isArray(t))
+      for (let s = 0, r = t.length; s < r; ++s)
+        this.removeEventListener(t[s], e);
+    else
+      this.removeEventListener(t, e);
+  }
+}
+function Be(i) {
+  if (Array.isArray(i))
+    for (let t = 0, e = i.length; t < e; ++t)
+      zt(i[t]);
+  else
+    zt(
+      /** @type {import("./events.js").EventsKey} */
+      i
+    );
+}
+function E() {
+  throw new Error("Unimplemented abstract method.");
+}
+let Ke = 0;
+function Je(i) {
+  return i.ol_uid || (i.ol_uid = String(++Ke));
+}
+class Gt extends he {
+  /**
+   * @param {string} type The event type.
+   * @param {string} key The property name.
+   * @param {*} oldValue The old value for `key`.
+   */
+  constructor(t, e, n) {
+    super(t), this.key = e, this.oldValue = n;
+  }
+}
+class ce extends qe {
+  /**
+   * @param {Object<string, *>} [values] An object with key-value pairs.
+   */
+  constructor(t) {
+    super(), this.on, this.once, this.un, Je(this), this.values_ = null, t !== void 0 && this.setProperties(t);
+  }
+  /**
+   * Gets a value.
+   * @param {string} key Key name.
+   * @return {*} Value.
+   * @api
+   */
+  get(t) {
+    let e;
+    return this.values_ && this.values_.hasOwnProperty(t) && (e = this.values_[t]), e;
+  }
+  /**
+   * Get a list of object property names.
+   * @return {Array<string>} List of property names.
+   * @api
+   */
+  getKeys() {
+    return this.values_ && Object.keys(this.values_) || [];
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>} Object.
+   * @api
+   */
+  getProperties() {
+    return this.values_ && Object.assign({}, this.values_) || {};
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>?} Object.
+   */
+  getPropertiesInternal() {
+    return this.values_;
+  }
+  /**
+   * @return {boolean} The object has properties.
+   */
+  hasProperties() {
+    return !!this.values_;
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {*} oldValue Old value.
+   */
+  notify(t, e) {
+    let n;
+    n = `change:${t}`, this.hasListener(n) && this.dispatchEvent(new Gt(n, t, e)), n = Le.PROPERTYCHANGE, this.hasListener(n) && this.dispatchEvent(new Gt(n, t, e));
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  addChangeListener(t, e) {
+    this.addEventListener(`change:${t}`, e);
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  removeChangeListener(t, e) {
+    this.removeEventListener(`change:${t}`, e);
+  }
+  /**
+   * Sets a value.
+   * @param {string} key Key name.
+   * @param {*} value Value.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  set(t, e, n) {
+    const s = this.values_ || (this.values_ = {});
+    if (n)
+      s[t] = e;
+    else {
+      const r = s[t];
+      s[t] = e, r !== e && this.notify(t, r);
+    }
+  }
+  /**
+   * Sets a collection of key-value pairs.  Note that this changes any existing
+   * properties and adds new ones (it does not remove any existing properties).
+   * @param {Object<string, *>} values Values.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  setProperties(t, e) {
+    for (const n in t)
+      this.set(n, t[n], e);
+  }
+  /**
+   * Apply any properties from another object without triggering events.
+   * @param {BaseObject} source The source object.
+   * @protected
+   */
+  applyProperties(t) {
+    t.values_ && Object.assign(this.values_ || (this.values_ = {}), t.values_);
+  }
+  /**
+   * Unsets a property.
+   * @param {string} key Key name.
+   * @param {boolean} [silent] Unset without triggering an event.
+   * @api
+   */
+  unset(t, e) {
+    if (this.values_ && t in this.values_) {
+      const n = this.values_[t];
+      delete this.values_[t], He(this.values_) && (this.values_ = null), e || this.notify(t, n);
+    }
+  }
+}
+function y(i, t) {
+  if (!i)
+    throw new Error(t);
+}
+const M = {
+  UNKNOWN: 0,
+  INTERSECTING: 1,
+  ABOVE: 2,
+  RIGHT: 4,
+  BELOW: 8,
+  LEFT: 16
+};
+function fe(i, t, e) {
+  let n, s;
+  return t < i[0] ? n = i[0] - t : i[2] < t ? n = t - i[2] : n = 0, e < i[1] ? s = i[1] - e : i[3] < e ? s = e - i[3] : s = 0, n * n + s * s;
+}
+function Qe(i, t, e) {
+  return i[0] <= t && t <= i[2] && i[1] <= e && e <= i[3];
+}
+function Ot(i, t) {
+  const e = i[0], n = i[1], s = i[2], r = i[3], o = t[0], a = t[1];
+  let l = M.UNKNOWN;
+  return o < e ? l = l | M.LEFT : o > s && (l = l | M.RIGHT), a < n ? l = l | M.BELOW : a > r && (l = l | M.ABOVE), l === M.UNKNOWN && (l = M.INTERSECTING), l;
+}
+function ge() {
+  return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+}
+function ct(i, t, e, n, s) {
+  return s ? (s[0] = i, s[1] = t, s[2] = e, s[3] = n, s) : [i, t, e, n];
+}
+function de(i) {
+  return ct(1 / 0, 1 / 0, -1 / 0, -1 / 0, i);
+}
+function tn(i, t) {
+  const e = i[0], n = i[1];
+  return ct(e, n, e, n, t);
+}
+function en(i, t, e, n, s) {
+  const r = de(s);
+  return me(r, i, t, e, n);
+}
+function me(i, t, e, n, s) {
+  for (; e < n; e += s)
+    nn(i, t[e], t[e + 1]);
+  return i;
+}
+function nn(i, t, e) {
+  i[0] = Math.min(i[0], t), i[1] = Math.min(i[1], e), i[2] = Math.max(i[2], t), i[3] = Math.max(i[3], e);
+}
+function sn(i, t) {
+  let e;
+  return e = t(rn(i)), e || (e = t(on(i)), e) || (e = t(un(i)), e) || (e = t(_e(i)), e) ? e : !1;
+}
+function rn(i) {
+  return [i[0], i[1]];
+}
+function on(i) {
+  return [i[2], i[1]];
+}
+function rt(i) {
+  return [(i[0] + i[2]) / 2, (i[1] + i[3]) / 2];
+}
+function an(i, t, e, n, s) {
+  const [r, o, a, l, h, u, c, f] = ln(
+    i,
+    t,
+    e,
+    n
+  );
+  return ct(
+    Math.min(r, a, h, c),
+    Math.min(o, l, u, f),
+    Math.max(r, a, h, c),
+    Math.max(o, l, u, f),
+    s
+  );
+}
+function ln(i, t, e, n) {
+  const s = t * n[0] / 2, r = t * n[1] / 2, o = Math.cos(e), a = Math.sin(e), l = s * o, h = s * a, u = r * o, c = r * a, f = i[0], g = i[1];
+  return [
+    f - l + c,
+    g - h - u,
+    f - l - c,
+    g - h + u,
+    f + l - c,
+    g + h + u,
+    f + l + c,
+    g + h - u,
+    f - l + c,
+    g - h - u
+  ];
+}
+function k(i) {
+  return i[3] - i[1];
+}
+function _e(i) {
+  return [i[0], i[3]];
+}
+function un(i) {
+  return [i[2], i[3]];
+}
+function D(i) {
+  return i[2] - i[0];
+}
+function hn(i, t) {
+  return i[0] <= t[2] && i[2] >= t[0] && i[1] <= t[3] && i[3] >= t[1];
+}
+function Re(i) {
+  return i[2] < i[0] || i[3] < i[1];
+}
+function cn(i, t) {
+  return t ? (t[0] = i[0], t[1] = i[1], t[2] = i[2], t[3] = i[3], t) : i;
+}
+function fn(i, t, e) {
+  let n = !1;
+  const s = Ot(i, t), r = Ot(i, e);
+  if (s === M.INTERSECTING || r === M.INTERSECTING)
+    n = !0;
+  else {
+    const o = i[0], a = i[1], l = i[2], h = i[3], u = t[0], c = t[1], f = e[0], g = e[1], d = (g - c) / (f - u);
+    let m, _;
+    r & M.ABOVE && !(s & M.ABOVE) && (m = f - (g - h) / d, n = m >= o && m <= l), !n && r & M.RIGHT && !(s & M.RIGHT) && (_ = g - (f - l) * d, n = _ >= a && _ <= h), !n && r & M.BELOW && !(s & M.BELOW) && (m = f - (g - a) / d, n = m >= o && m <= l), !n && r & M.LEFT && !(s & M.LEFT) && (_ = g - (f - o) * d, n = _ >= a && _ <= h);
+  }
+  return n;
+}
+function p(i, t, e) {
+  return Math.min(Math.max(i, t), e);
+}
+function gn(i, t, e, n, s, r) {
+  const o = s - e, a = r - n;
+  if (o !== 0 || a !== 0) {
+    const l = ((i - e) * o + (t - n) * a) / (o * o + a * a);
+    l > 1 ? (e = s, n = r) : l > 0 && (e += o * l, n += a * l);
+  }
+  return U(i, t, e, n);
+}
+function U(i, t, e, n) {
+  const s = e - i, r = n - t;
+  return s * s + r * r;
+}
+function Lt(i) {
+  return i * 180 / Math.PI;
+}
+function H(i) {
+  return i * Math.PI / 180;
+}
+function bt(i, t) {
+  const e = i % t;
+  return e * t < 0 ? e + t : e;
+}
+function dn(i, t, e) {
+  return i + e * (t - i);
+}
+function xe(i, t) {
+  const e = Math.pow(10, t);
+  return Math.round(i * e) / e;
+}
+function K(i, t) {
+  return Math.floor(xe(i, t));
+}
+function J(i, t) {
+  return Math.ceil(xe(i, t));
+}
+function Tt(i, t, e) {
+  if (i >= t && i < e)
+    return i;
+  const n = e - t;
+  return ((i - t) % n + n) % n + t;
+}
+function mn(...i) {
+  console.warn(...i);
+}
+function _n(i, t) {
+  return i[0] += +t[0], i[1] += +t[1], i;
+}
+function ot(i, t) {
+  let e = !0;
+  for (let n = i.length - 1; n >= 0; --n)
+    if (i[n] != t[n]) {
+      e = !1;
+      break;
+    }
+  return e;
+}
+function Rn(i, t) {
+  const e = Math.cos(t), n = Math.sin(t), s = i[0] * e - i[1] * n, r = i[1] * e + i[0] * n;
+  return i[0] = s, i[1] = r, i;
+}
+function xn(i, t, e) {
+  const n = t.getExtent();
+  let s = 0;
+  return t.canWrapX() && (i[0] < n[0] || i[0] > n[2]) && (e = e || D(n), s = Math.floor(
+    (i[0] - n[0]) / e
+  )), s;
+}
+const Me = {
+  // 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 ft {
+  /**
+   * @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_ || Me[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 {GetPointResolution|undefined} The custom point
+   * resolution function (if set).
+   */
+  getPointResolutionFunc() {
+    return this.getPointResolutionFunc_;
+  }
+}
+const B = 6378137, b = Math.PI * B, Mn = [-b, -b, b, b], Cn = [-180, -85, 180, 85], Q = B * Math.log(Math.tan(Math.PI / 2));
+class z extends ft {
+  /**
+   * @param {string} code Code.
+   */
+  constructor(t) {
+    super({
+      code: t,
+      units: "m",
+      extent: Mn,
+      global: !0,
+      worldExtent: Cn,
+      getPointResolution: function(e, n) {
+        return e / Math.cosh(n[1] / B);
+      }
+    });
+  }
+}
+const Ut = [
+  new z("EPSG:3857"),
+  new z("EPSG:102100"),
+  new z("EPSG:102113"),
+  new z("EPSG:900913"),
+  new z("http://www.opengis.net/def/crs/EPSG/0/3857"),
+  new z("http://www.opengis.net/gml/srs/epsg.xml#3857")
+];
+function En(i, t, e, n) {
+  const s = i.length;
+  e = e > 1 ? e : 2, n = n ?? e, t === void 0 && (e > 2 ? t = i.slice() : t = new Array(s));
+  for (let r = 0; r < s; r += n) {
+    t[r] = b * i[r] / 180;
+    let o = B * Math.log(Math.tan(Math.PI * (+i[r + 1] + 90) / 360));
+    o > Q ? o = Q : o < -Q && (o = -Q), t[r + 1] = o;
+  }
+  return t;
+}
+function Tn(i, t, e, n) {
+  const s = i.length;
+  e = e > 1 ? e : 2, n = n ?? e, t === void 0 && (e > 2 ? t = i.slice() : t = new Array(s));
+  for (let r = 0; r < s; r += n)
+    t[r] = 180 * i[r] / b, t[r + 1] = 360 * Math.atan(Math.exp(i[r + 1] / B)) / Math.PI - 90;
+  return t;
+}
+const pn = 6378137, Vt = [-180, -90, 180, 90], In = Math.PI * pn / 180;
+class X extends ft {
+  /**
+   * @param {string} code Code.
+   * @param {string} [axisOrientation] Axis orientation.
+   */
+  constructor(t, e) {
+    super({
+      code: t,
+      units: "degrees",
+      extent: Vt,
+      axisOrientation: e,
+      global: !0,
+      metersPerUnit: In,
+      worldExtent: Vt
+    });
+  }
+}
+const Dt = [
+  new X("CRS:84"),
+  new X("EPSG:4326", "neu"),
+  new X("urn:ogc:def:crs:OGC:1.3:CRS84"),
+  new X("urn:ogc:def:crs:OGC:2:84"),
+  new X("http://www.opengis.net/def/crs/OGC/1.3/CRS84"),
+  new X("http://www.opengis.net/gml/srs/epsg.xml#4326", "neu"),
+  new X("http://www.opengis.net/def/crs/EPSG/0/4326", "neu")
+];
+let pt = {};
+function it(i) {
+  return pt[i] || pt[i.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\w+)$/, "EPSG:$3")] || null;
+}
+function yn(i, t) {
+  pt[i] = t;
+}
+let V = {};
+function Z(i, t, e) {
+  const n = i.getCode(), s = t.getCode();
+  n in V || (V[n] = {}), V[n][s] = e;
+}
+function st(i, t) {
+  return i in V && t in V[i] ? V[i][t] : null;
+}
+const at = 0.9996, T = 669438e-8, gt = T * T, dt = gt * T, N = T / (1 - T), Wt = Math.sqrt(1 - T), W = (1 - Wt) / (1 + Wt), Ce = W * W, St = Ce * W, At = St * W, Ee = At * W, Te = 1 - T / 4 - 3 * gt / 64 - 5 * dt / 256, wn = 3 * T / 8 + 3 * gt / 32 + 45 * dt / 1024, Sn = 15 * gt / 256 + 45 * dt / 1024, An = 35 * dt / 3072, vn = 3 / 2 * W - 27 / 32 * St + 269 / 512 * Ee, Pn = 21 / 16 * Ce - 55 / 32 * At, Fn = 151 / 96 * St - 417 / 128 * Ee, Xn = 1097 / 512 * At, lt = 6378137;
+function Nn(i, t, e) {
+  const n = i - 5e5, o = (e.north ? t : t - 1e7) / at / (lt * Te), a = o + vn * Math.sin(2 * o) + Pn * Math.sin(4 * o) + Fn * Math.sin(6 * o) + Xn * Math.sin(8 * o), l = Math.sin(a), h = l * l, u = Math.cos(a), c = l / u, f = c * c, g = f * f, d = 1 - T * h, m = Math.sqrt(1 - T * h), _ = lt / m, x = (1 - T) / d, R = N * u ** 2, w = R * R, C = n / (_ * at), F = C * C, $ = F * C, Yt = $ * C, Zt = Yt * C, ze = Zt * C, Ge = a - c / x * (F / 2 - Yt / 24 * (5 + 3 * f + 10 * R - 4 * w - 9 * N)) + ze / 720 * (61 + 90 * f + 298 * R + 45 * g - 252 * N - 3 * w);
+  let mt = (C - $ / 6 * (1 + 2 * f + R) + Zt / 120 * (5 - 2 * R + 28 * f - 3 * w + 8 * N + 24 * g)) / u;
+  return mt = Tt(
+    mt + H(pe(e.number)),
+    -Math.PI,
+    Math.PI
+  ), [Lt(mt), Lt(Ge)];
+}
+const $t = -80, Ht = 84, Yn = -180, Zn = 180;
+function jn(i, t, e) {
+  i = Tt(i, Yn, Zn), t < $t ? t = $t : t > Ht && (t = Ht);
+  const n = H(t), s = Math.sin(n), r = Math.cos(n), o = s / r, a = o * o, l = a * a, h = H(i), u = pe(e.number), c = H(u), f = lt / Math.sqrt(1 - T * s ** 2), g = N * r ** 2, d = r * Tt(h - c, -Math.PI, Math.PI), m = d * d, _ = m * d, x = _ * d, R = x * d, w = R * d, C = lt * (Te * n - wn * Math.sin(2 * n) + Sn * Math.sin(4 * n) - An * Math.sin(6 * n)), F = at * f * (d + _ / 6 * (1 - a + g) + R / 120 * (5 - 18 * a + l + 72 * g - 58 * N)) + 5e5;
+  let $ = at * (C + f * o * (m / 2 + x / 24 * (5 - a + 9 * g + 4 * g ** 2) + w / 720 * (61 - 58 * a + l + 600 * g - 330 * N)));
+  return e.north || ($ += 1e7), [F, $];
+}
+function pe(i) {
+  return (i - 1) * 6 - 180 + 3;
+}
+const zn = [
+  /^EPSG:(\d+)$/,
+  /^urn:ogc:def:crs:EPSG::(\d+)$/,
+  /^http:\/\/www\.opengis\.net\/def\/crs\/EPSG\/0\/(\d+)$/
+];
+function Ie(i) {
+  let t = 0;
+  for (const s of zn) {
+    const r = i.match(s);
+    if (r) {
+      t = parseInt(r[1]);
+      break;
+    }
+  }
+  if (!t)
+    return null;
+  let e = 0, n = !1;
+  return t > 32700 && t < 32761 ? e = t - 32700 : t > 32600 && t < 32661 && (n = !0, e = t - 32600), e ? { number: e, north: n } : null;
+}
+function kt(i, t) {
+  return function(e, n, s, r) {
+    const o = e.length;
+    s = s > 1 ? s : 2, r = r ?? s, n || (s > 2 ? n = e.slice() : n = new Array(o));
+    for (let a = 0; a < o; a += r) {
+      const l = e[a], h = e[a + 1], u = i(l, h, t);
+      n[a] = u[0], n[a + 1] = u[1];
+    }
+    return n;
+  };
+}
+function Gn(i) {
+  return Ie(i) ? new ft({ code: i, units: "m" }) : null;
+}
+function On(i) {
+  const t = Ie(i.getCode());
+  return t ? {
+    forward: kt(jn, t),
+    inverse: kt(Nn, t)
+  } : null;
+}
+const Ln = [On], bn = [Gn];
+let It = !0;
+function Un(i) {
+  It = !1;
+}
+function ye(i, t) {
+  if (t !== void 0) {
+    for (let e = 0, n = i.length; e < n; ++e)
+      t[e] = i[e];
+    t = t;
+  } else
+    t = i.slice();
+  return t;
+}
+function ut(i) {
+  yn(i.getCode(), i), Z(i, i, ye);
+}
+function Vn(i) {
+  i.forEach(ut);
+}
+function j(i) {
+  if (typeof i != "string")
+    return i;
+  const t = it(i);
+  if (t)
+    return t;
+  for (const e of bn) {
+    const n = e(i);
+    if (n)
+      return n;
+  }
+  return null;
+}
+function yt(i) {
+  Vn(i), i.forEach(function(t) {
+    i.forEach(function(e) {
+      t !== e && Z(t, e, ye);
+    });
+  });
+}
+function Dn(i, t, e, n) {
+  i.forEach(function(s) {
+    t.forEach(function(r) {
+      Z(s, r, e), Z(r, s, n);
+    });
+  });
+}
+function vt(i, t) {
+  return i ? typeof i == "string" ? j(i) : (
+    /** @type {Projection} */
+    i
+  ) : j(t);
+}
+function qt(i) {
+  return (
+    /**
+     * @param {Array<number>} input Input.
+     * @param {Array<number>} [output] Output.
+     * @param {number} [dimension] Dimensions that should be transformed.
+     * @param {number} [stride] Stride.
+     * @return {Array<number>} Output.
+     */
+    function(t, e, n, s) {
+      const r = t.length;
+      n = n !== void 0 ? n : 2, s = s ?? n, e = e !== void 0 ? e : new Array(r);
+      for (let o = 0; o < r; o += s) {
+        const a = i(t.slice(o, o + n)), l = a.length;
+        for (let h = 0, u = s; h < u; ++h)
+          e[o + h] = h >= l ? t[o + h] : a[h];
+      }
+      return e;
+    }
+  );
+}
+function Wn(i, t, e, n) {
+  const s = j(i), r = j(t);
+  Z(
+    s,
+    r,
+    qt(e)
+  ), Z(
+    r,
+    s,
+    qt(n)
+  );
+}
+function $n(i, t) {
+  const e = i.getCode(), n = t.getCode();
+  let s = st(e, n);
+  if (s)
+    return s;
+  let r = null, o = null;
+  for (const l of Ln)
+    r || (r = l(i)), o || (o = l(t));
+  if (!r && !o)
+    return null;
+  const a = "EPSG:4326";
+  if (o)
+    if (r)
+      s = Rt(
+        r.inverse,
+        o.forward
+      );
+    else {
+      const l = st(e, a);
+      l && (s = Rt(
+        l,
+        o.forward
+      ));
+    }
+  else {
+    const l = st(a, n);
+    l && (s = Rt(
+      r.inverse,
+      l
+    ));
+  }
+  return s && (ut(i), ut(t), Z(i, t, s)), s;
+}
+function Rt(i, t) {
+  return function(e, n, s, r) {
+    return n = i(e, n, s, r), t(n, n, s, r);
+  };
+}
+function Bt(i, t) {
+  const e = j(i), n = j(t);
+  return $n(e, n);
+}
+function Kt(i, t) {
+  return i;
+}
+function S(i, t) {
+  return It && !ot(i, [0, 0]) && i[0] >= -180 && i[0] <= 180 && i[1] >= -90 && i[1] <= 90 && (It = !1, mn(
+    "Call useGeographic() from ol/proj once to work with [longitude, latitude] coordinates."
+  )), i;
+}
+function Hn(i, t) {
+  return i;
+}
+function tt(i, t) {
+  return i;
+}
+function Jt(i, t, e) {
+  return function(n) {
+    let s, r;
+    if (i.canWrapX()) {
+      const o = i.getExtent(), a = D(o);
+      n = n.slice(0), r = xn(n, i, a), r && (n[0] = n[0] - r * a), n[0] = p(n[0], o[0], o[2]), n[1] = p(n[1], o[1], o[3]), s = e(n);
+    } else
+      s = e(n);
+    return r && t.canWrapX() && (s[0] += r * D(t.getExtent())), s;
+  };
+}
+function kn() {
+  yt(Ut), yt(Dt), Dn(
+    Dt,
+    Ut,
+    En,
+    Tn
+  );
+}
+kn();
+new Array(6);
+function qn() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function Bn(i, t, e, n, s, r, o, a) {
+  const l = Math.sin(r), h = Math.cos(r);
+  return i[0] = n * h, i[1] = s * l, i[2] = -n * l, i[3] = s * h, i[4] = o * n * h - a * n * l + t, i[5] = o * s * l + a * s * h + e, i;
+}
+function Kn(i, t, e, n, s, r, o) {
+  r = r || [], o = o || 2;
+  let a = 0;
+  for (let l = t; l < e; l += n) {
+    const h = i[l], u = i[l + 1];
+    r[a++] = s[0] * h + s[2] * u + s[4], r[a++] = s[1] * h + s[3] * u + s[5];
+    for (let c = 2; c < o; c++)
+      r[a++] = i[l + c];
+  }
+  return r && r.length != a && (r.length = a), r;
+}
+function Jn(i, t, e, n, s, r, o) {
+  o = o || [];
+  const a = Math.cos(s), l = Math.sin(s), h = r[0], u = r[1];
+  let c = 0;
+  for (let f = t; f < e; f += n) {
+    const g = i[f] - h, d = i[f + 1] - u;
+    o[c++] = h + g * a - d * l, o[c++] = u + g * l + d * a;
+    for (let m = f + 2; m < f + n; ++m)
+      o[c++] = i[m];
+  }
+  return o && o.length != c && (o.length = c), o;
+}
+function Qn(i, t, e, n, s, r, o, a) {
+  a = a || [];
+  const l = o[0], h = o[1];
+  let u = 0;
+  for (let c = t; c < e; c += n) {
+    const f = i[c] - l, g = i[c + 1] - h;
+    a[u++] = l + s * f, a[u++] = h + r * g;
+    for (let d = c + 2; d < c + n; ++d)
+      a[u++] = i[d];
+  }
+  return a && a.length != u && (a.length = u), a;
+}
+function ti(i, t, e, n, s, r, o) {
+  o = o || [];
+  let a = 0;
+  for (let l = t; l < e; l += n) {
+    o[a++] = i[l] + s, o[a++] = i[l + 1] + r;
+    for (let h = l + 2; h < l + n; ++h)
+      o[a++] = i[h];
+  }
+  return o && o.length != a && (o.length = a), o;
+}
+const Qt = qn(), ei = [NaN, NaN];
+class ni extends ce {
+  constructor() {
+    super(), this.extent_ = ge(), this.extentRevision_ = -1, this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = 0, this.simplifyTransformedInternal = $e(
+      (t, e, n) => {
+        if (!n)
+          return this.getSimplifiedGeometry(e);
+        const s = this.clone();
+        return s.applyTransform(n), s.getSimplifiedGeometry(e);
+      }
+    );
+  }
+  /**
+   * Get a transformed and simplified version of the geometry.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @param {import("../proj.js").TransformFunction} [transform] Optional transform function.
+   * @return {Geometry} Simplified geometry.
+   */
+  simplifyTransformed(t, e) {
+    return this.simplifyTransformedInternal(
+      this.getRevision(),
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @abstract
+   * @return {!Geometry} Clone.
+   */
+  clone() {
+    return E();
+  }
+  /**
+   * @abstract
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, n, s) {
+    return E();
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    return this.closestPointXY(t, e, ei, 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 E();
+  }
+  /**
+   * Get the extent of the geometry.
+   * @param {import("../extent.js").Extent} [extent] Extent.
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  getExtent(t) {
+    if (this.extentRevision_ != this.getRevision()) {
+      const e = this.computeExtent(this.extent_);
+      (isNaN(e[0]) || isNaN(e[1])) && de(e), this.extentRevision_ = this.getRevision();
+    }
+    return cn(this.extent_, t);
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} angle Rotation angle in radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   */
+  rotate(t, e) {
+    E();
+  }
+  /**
+   * Scale the geometry (with an optional origin).  This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} sx The scaling factor in the x-direction.
+   * @param {number} [sy] The scaling factor in the y-direction (defaults to sx).
+   * @param {import("../coordinate.js").Coordinate} [anchor] The scale origin (defaults to the center
+   *     of the geometry extent).
+   * @api
+   */
+  scale(t, e, n) {
+    E();
+  }
+  /**
+   * Create a simplified version of this geometry.  For linestrings, this uses
+   * the [Douglas Peucker](https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm)
+   * algorithm.  For polygons, a quantization-based
+   * simplification is used to preserve topology.
+   * @param {number} tolerance The tolerance distance for simplification.
+   * @return {Geometry} A new, simplified version of the original geometry.
+   * @api
+   */
+  simplify(t) {
+    return this.getSimplifiedGeometry(t * t);
+  }
+  /**
+   * Create a simplified version of this geometry using the Douglas Peucker
+   * algorithm.
+   * See https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {Geometry} Simplified geometry.
+   */
+  getSimplifiedGeometry(t) {
+    return E();
+  }
+  /**
+   * Get the type of this geometry.
+   * @abstract
+   * @return {Type} Geometry type.
+   */
+  getType() {
+    return E();
+  }
+  /**
+   * Apply a transform function to the coordinates of the geometry.
+   * The geometry is modified in place.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   * @abstract
+   * @param {import("../proj.js").TransformFunction} transformFn Transform function.
+   * Called with a flat array of geometry coordinates.
+   */
+  applyTransform(t) {
+    E();
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @abstract
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   */
+  intersectsExtent(t) {
+    return E();
+  }
+  /**
+   * Translate the geometry.  This modifies the geometry coordinates in place.  If
+   * instead you want a new geometry, first `clone()` this geometry.
+   * @abstract
+   * @param {number} deltaX Delta X.
+   * @param {number} deltaY Delta Y.
+   * @api
+   */
+  translate(t, e) {
+    E();
+  }
+  /**
+   * Transform each coordinate of the geometry from one coordinate reference
+   * system to another. The geometry is modified in place.
+   * For example, a line will be transformed to a line and a circle to a circle.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   *
+   * @param {import("../proj.js").ProjectionLike} source The current projection.  Can be a
+   *     string identifier or a {@link module:ol/proj/Projection~Projection} object.
+   * @param {import("../proj.js").ProjectionLike} destination The desired projection.  Can be a
+   *     string identifier or a {@link module:ol/proj/Projection~Projection} object.
+   * @return {this} This geometry.  Note that original geometry is
+   *     modified in place.
+   * @api
+   */
+  transform(t, e) {
+    const n = j(t), s = n.getUnits() == "tile-pixels" ? function(r, o, a) {
+      const l = n.getExtent(), h = n.getWorldExtent(), u = k(h) / k(l);
+      Bn(
+        Qt,
+        h[0],
+        h[3],
+        u,
+        -u,
+        0,
+        0,
+        0
+      );
+      const c = Kn(
+        r,
+        0,
+        r.length,
+        a,
+        Qt,
+        o
+      ), f = Bt(n, e);
+      return f ? f(c, c, a) : c;
+    } : Bt(n, e);
+    return this.applyTransform(s), this;
+  }
+}
+class Pt extends ni {
+  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 en(
+      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.
+   * @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 = te(t), this.layout = t, this.flatCoordinates = e;
+  }
+  /**
+   * @abstract
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  setCoordinates(t, e) {
+    E();
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout|undefined} layout Layout.
+   * @param {Array<*>} coordinates Coordinates.
+   * @param {number} nesting Nesting.
+   * @protected
+   */
+  setLayout(t, e, n) {
+    let s;
+    if (t)
+      s = te(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];
+      }
+      s = e.length, t = ii(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
+   * @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 s = this.getStride();
+      Jn(
+        n,
+        0,
+        n.length,
+        s,
+        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 = rt(this.getExtent()));
+    const s = this.getFlatCoordinates();
+    if (s) {
+      const r = this.getStride();
+      Qn(
+        s,
+        0,
+        s.length,
+        r,
+        t,
+        e,
+        n,
+        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
+   * @override
+   */
+  translate(t, e) {
+    const n = this.getFlatCoordinates();
+    if (n) {
+      const s = this.getStride();
+      ti(
+        n,
+        0,
+        n.length,
+        s,
+        t,
+        e,
+        n
+      ), this.changed();
+    }
+  }
+}
+function ii(i) {
+  let t;
+  return i == 2 ? t = "XY" : i == 3 ? t = "XYZ" : i == 4 && (t = "XYZM"), /** @type {import("./Geometry.js").GeometryLayout} */
+  t;
+}
+function te(i) {
+  let t;
+  return i == "XY" ? t = 2 : i == "XYZ" || i == "XYM" ? t = 3 : i == "XYZM" && (t = 4), /** @type {number} */
+  t;
+}
+function we(i, t, e, n) {
+  let s = 0;
+  const r = i[e - n], o = i[e - n + 1];
+  let a = 0, l = 0;
+  for (; t < e; t += n) {
+    const h = i[t] - r, u = i[t + 1] - o;
+    s += l * h - a * u, a = h, l = u;
+  }
+  return s / 2;
+}
+function si(i, t, e, n) {
+  let s = 0;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const a = e[r];
+    s += we(i, t, a, n), t = a;
+  }
+  return s;
+}
+function ee(i, t, e, n, s, r, o) {
+  const a = i[t], l = i[t + 1], h = i[e] - a, u = i[e + 1] - l;
+  let c;
+  if (h === 0 && u === 0)
+    c = t;
+  else {
+    const f = ((s - a) * h + (r - l) * u) / (h * h + u * u);
+    if (f > 1)
+      c = e;
+    else if (f > 0) {
+      for (let g = 0; g < n; ++g)
+        o[g] = dn(
+          i[t + g],
+          i[e + g],
+          f
+        );
+      o.length = n;
+      return;
+    } else
+      c = t;
+  }
+  for (let f = 0; f < n; ++f)
+    o[f] = i[c + f];
+  o.length = n;
+}
+function Se(i, t, e, n, s) {
+  let r = i[t], o = i[t + 1];
+  for (t += n; t < e; t += n) {
+    const a = i[t], l = i[t + 1], h = U(r, o, a, l);
+    h > s && (s = h), r = a, o = l;
+  }
+  return s;
+}
+function ri(i, t, e, n, s) {
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const a = e[r];
+    s = Se(i, t, a, n, s), t = a;
+  }
+  return s;
+}
+function Ae(i, t, e, n, s, r, o, a, l, h, u) {
+  if (t == e)
+    return h;
+  let c, f;
+  if (s === 0) {
+    if (f = U(
+      o,
+      a,
+      i[t],
+      i[t + 1]
+    ), f < h) {
+      for (c = 0; c < n; ++c)
+        l[c] = i[t + c];
+      return l.length = n, f;
+    }
+    return h;
+  }
+  u = u || [NaN, NaN];
+  let g = t + n;
+  for (; g < e; )
+    if (ee(
+      i,
+      g - n,
+      g,
+      n,
+      o,
+      a,
+      u
+    ), f = U(o, a, u[0], u[1]), f < h) {
+      for (h = f, c = 0; c < n; ++c)
+        l[c] = u[c];
+      l.length = n, g += n;
+    } else
+      g += n * Math.max(
+        (Math.sqrt(f) - Math.sqrt(h)) / s | 0,
+        1
+      );
+  if (ee(
+    i,
+    e - n,
+    t,
+    n,
+    o,
+    a,
+    u
+  ), f = U(o, a, u[0], u[1]), f < h) {
+    for (h = f, c = 0; c < n; ++c)
+      l[c] = u[c];
+    l.length = n;
+  }
+  return h;
+}
+function oi(i, t, e, n, s, r, o, a, l, h, u) {
+  u = u || [NaN, NaN];
+  for (let c = 0, f = e.length; c < f; ++c) {
+    const g = e[c];
+    h = Ae(
+      i,
+      t,
+      g,
+      n,
+      s,
+      r,
+      o,
+      a,
+      l,
+      h,
+      u
+    ), t = g;
+  }
+  return h;
+}
+function ai(i, t, e, n) {
+  for (let s = 0, r = e.length; s < r; ++s)
+    i[t++] = e[s];
+  return t;
+}
+function ve(i, t, e, n) {
+  for (let s = 0, r = e.length; s < r; ++s) {
+    const o = e[s];
+    for (let a = 0; a < n; ++a)
+      i[t++] = o[a];
+  }
+  return t;
+}
+function li(i, t, e, n, s) {
+  s = s || [];
+  let r = 0;
+  for (let o = 0, a = e.length; o < a; ++o) {
+    const l = ve(
+      i,
+      t,
+      e[o],
+      n
+    );
+    s[r++] = l, t = l;
+  }
+  return s.length = r, s;
+}
+function Pe(i, t, e, n, s) {
+  s = s !== void 0 ? s : [];
+  let r = 0;
+  for (let o = t; o < e; o += n)
+    s[r++] = i.slice(o, o + n);
+  return s.length = r, s;
+}
+function ui(i, t, e, n, s) {
+  s = s !== void 0 ? s : [];
+  let r = 0;
+  for (let o = 0, a = e.length; o < a; ++o) {
+    const l = e[o];
+    s[r++] = Pe(
+      i,
+      t,
+      l,
+      n,
+      s[r]
+    ), t = l;
+  }
+  return s.length = r, s;
+}
+function hi(i, t, e, n, s, r, o) {
+  const a = (e - t) / n;
+  if (a < 3) {
+    for (; t < e; t += n)
+      r[o++] = i[t], r[o++] = i[t + 1];
+    return o;
+  }
+  const l = new Array(a);
+  l[0] = 1, l[a - 1] = 1;
+  const h = [t, e - n];
+  let u = 0;
+  for (; h.length > 0; ) {
+    const c = h.pop(), f = h.pop();
+    let g = 0;
+    const d = i[f], m = i[f + 1], _ = i[c], x = i[c + 1];
+    for (let R = f + n; R < c; R += n) {
+      const w = i[R], C = i[R + 1], F = gn(w, C, d, m, _, x);
+      F > g && (u = R, g = F);
+    }
+    g > s && (l[(u - t) / n] = 1, f + n < u && h.push(f, u), u + n < c && h.push(u, c));
+  }
+  for (let c = 0; c < a; ++c)
+    l[c] && (r[o++] = i[t + c * n], r[o++] = i[t + c * n + 1]);
+  return o;
+}
+function G(i, t) {
+  return t * Math.round(i / t);
+}
+function ci(i, t, e, n, s, r, o) {
+  if (t == e)
+    return o;
+  let a = G(i[t], s), l = G(i[t + 1], s);
+  t += n, r[o++] = a, r[o++] = l;
+  let h, u;
+  do
+    if (h = G(i[t], s), u = G(i[t + 1], s), t += n, t == e)
+      return r[o++] = h, r[o++] = u, o;
+  while (h == a && u == l);
+  for (; t < e; ) {
+    const c = G(i[t], s), f = G(i[t + 1], s);
+    if (t += n, c == h && f == u)
+      continue;
+    const g = h - a, d = u - l, m = c - a, _ = f - l;
+    if (g * _ == d * m && (g < 0 && m < g || g == m || g > 0 && m > g) && (d < 0 && _ < d || d == _ || d > 0 && _ > d)) {
+      h = c, u = f;
+      continue;
+    }
+    r[o++] = h, r[o++] = u, a = h, l = u, h = c, u = f;
+  }
+  return r[o++] = h, r[o++] = u, o;
+}
+function fi(i, t, e, n, s, r, o, a) {
+  for (let l = 0, h = e.length; l < h; ++l) {
+    const u = e[l];
+    o = ci(
+      i,
+      t,
+      u,
+      n,
+      s,
+      r,
+      o
+    ), a.push(o), t = u;
+  }
+  return o;
+}
+class q extends Pt {
+  /**
+   * @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 q(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, s) {
+    return s < fe(this.getExtent(), t, e) ? s : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      Se(
+        this.flatCoordinates,
+        0,
+        this.flatCoordinates.length,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), Ae(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      n,
+      s
+    ));
+  }
+  /**
+   * Return the area of the linear ring on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return we(
+      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 Pe(
+      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 = hi(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e,
+      0
+    ), new q(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 = ve(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+class Ft extends Pt {
+  /**
+   * @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 Ft(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, s) {
+    const r = this.flatCoordinates, o = U(
+      t,
+      e,
+      r[0],
+      r[1]
+    );
+    if (o < s) {
+      const a = this.stride;
+      for (let l = 0; l < a; ++l)
+        n[l] = r[l];
+      return n.length = a, o;
+    }
+    return s;
+  }
+  /**
+   * 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 tn(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 Qe(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 = ai(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+function gi(i, t, e, n, s) {
+  return !sn(
+    s,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+     * @return {boolean} Contains (x, y).
+     */
+    function(o) {
+      return !Y(
+        i,
+        t,
+        e,
+        n,
+        o[0],
+        o[1]
+      );
+    }
+  );
+}
+function Y(i, t, e, n, s, r) {
+  let o = 0, a = i[e - n], l = i[e - n + 1];
+  for (; t < e; t += n) {
+    const h = i[t], u = i[t + 1];
+    l <= r ? u > r && (h - a) * (r - l) - (s - a) * (u - l) > 0 && o++ : u <= r && (h - a) * (r - l) - (s - a) * (u - l) < 0 && o--, a = h, l = u;
+  }
+  return o !== 0;
+}
+function Fe(i, t, e, n, s, r) {
+  if (e.length === 0 || !Y(i, t, e[0], n, s, r))
+    return !1;
+  for (let o = 1, a = e.length; o < a; ++o)
+    if (Y(i, e[o - 1], e[o], n, s, r))
+      return !1;
+  return !0;
+}
+function di(i, t, e, n, s, r, o) {
+  let a, l, h, u, c, f, g;
+  const d = s[r + 1], m = [];
+  for (let R = 0, w = e.length; R < w; ++R) {
+    const C = e[R];
+    for (u = i[C - n], f = i[C - n + 1], a = t; a < C; a += n)
+      c = i[a], g = i[a + 1], (d <= f && g <= d || f <= d && d <= g) && (h = (d - f) / (g - f) * (c - u) + u, m.push(h)), u = c, f = g;
+  }
+  let _ = NaN, x = -1 / 0;
+  for (m.sort(le), u = m[0], a = 1, l = m.length; a < l; ++a) {
+    c = m[a];
+    const R = Math.abs(c - u);
+    R > x && (h = (u + c) / 2, Fe(i, t, e, n, h, d) && (_ = h, x = R)), u = c;
+  }
+  return isNaN(_) && (_ = s[r]), [_, d, x];
+}
+function mi(i, t, e, n, s) {
+  let r;
+  for (t += n; t < e; t += n)
+    if (r = s(
+      i.slice(t - n, t),
+      i.slice(t, t + n)
+    ), r)
+      return r;
+  return !1;
+}
+function Xe(i, t, e, n, s, r) {
+  return r = r ?? me(ge(), i, t, e, n), hn(s, r) ? r[0] >= s[0] && r[2] <= s[2] || r[1] >= s[1] && r[3] <= s[3] ? !0 : mi(
+    i,
+    t,
+    e,
+    n,
+    /**
+     * @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, a) {
+      return fn(s, o, a);
+    }
+  ) : !1;
+}
+function Ne(i, t, e, n, s) {
+  return !!(Xe(i, t, e, n, s) || Y(
+    i,
+    t,
+    e,
+    n,
+    s[0],
+    s[1]
+  ) || Y(
+    i,
+    t,
+    e,
+    n,
+    s[0],
+    s[3]
+  ) || Y(
+    i,
+    t,
+    e,
+    n,
+    s[2],
+    s[1]
+  ) || Y(
+    i,
+    t,
+    e,
+    n,
+    s[2],
+    s[3]
+  ));
+}
+function _i(i, t, e, n, s) {
+  if (!Ne(i, t, e[0], n, s))
+    return !1;
+  if (e.length === 1)
+    return !0;
+  for (let r = 1, o = e.length; r < o; ++r)
+    if (gi(
+      i,
+      e[r - 1],
+      e[r],
+      n,
+      s
+    ) && !Xe(
+      i,
+      e[r - 1],
+      e[r],
+      n,
+      s
+    ))
+      return !1;
+  return !0;
+}
+function Ri(i, t, e, n) {
+  for (; t < e - n; ) {
+    for (let s = 0; s < n; ++s) {
+      const r = i[t + s];
+      i[t + s] = i[e - n + s], i[e - n + s] = r;
+    }
+    t += n, e -= n;
+  }
+}
+function Ye(i, t, e, n) {
+  let s = 0, r = i[e - n], o = i[e - n + 1];
+  for (; t < e; t += n) {
+    const a = i[t], l = i[t + 1];
+    s += (a - r) * (l + o), r = a, o = l;
+  }
+  return s === 0 ? void 0 : s > 0;
+}
+function xi(i, t, e, n, s) {
+  s = s !== void 0 ? s : !1;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const a = e[r], l = Ye(
+      i,
+      t,
+      a,
+      n
+    );
+    if (r === 0) {
+      if (s && l || !s && !l)
+        return !1;
+    } else if (s && !l || !s && l)
+      return !1;
+    t = a;
+  }
+  return !0;
+}
+function ne(i, t, e, n, s) {
+  s = s !== void 0 ? s : !1;
+  for (let r = 0, o = e.length; r < o; ++r) {
+    const a = e[r], l = Ye(
+      i,
+      t,
+      a,
+      n
+    );
+    (r === 0 ? s && l || !s && !l : s && !l || !s && l) && Ri(i, t, a, n), t = a;
+  }
+  return t;
+}
+class ht extends Pt {
+  /**
+   * @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 ? Ve(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 ht(
+      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, s) {
+    return s < fe(this.getExtent(), t, e) ? s : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      ri(
+        this.flatCoordinates,
+        0,
+        this.ends_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), oi(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      n,
+      s
+    ));
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   * @override
+   */
+  containsXY(t, e) {
+    return Fe(
+      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 si(
+      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(), ne(e, 0, this.ends_, this.stride, t)) : e = this.flatCoordinates, ui(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 = rt(this.getExtent());
+      this.flatInteriorPoint_ = di(
+        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 Ft(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 q(
+      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_, s = [];
+    let r = 0;
+    for (let o = 0, a = n.length; o < a; ++o) {
+      const l = n[o], h = new q(
+        e.slice(r, l),
+        t
+      );
+      s.push(h), r = l;
+    }
+    return s;
+  }
+  /**
+   * @return {Array<number>} Oriented flat coordinates.
+   */
+  getOrientedFlatCoordinates() {
+    if (this.orientedRevision_ != this.getRevision()) {
+      const t = this.flatCoordinates;
+      xi(t, 0, this.ends_, this.stride) ? this.orientedFlatCoordinates_ = t : (this.orientedFlatCoordinates_ = t.slice(), this.orientedFlatCoordinates_.length = ne(
+        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 = fi(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      Math.sqrt(t),
+      e,
+      0,
+      n
+    ), new ht(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 _i(
+      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 = li(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.ends_
+    );
+    this.flatCoordinates.length = n.length === 0 ? 0 : n[n.length - 1], this.changed();
+  }
+}
+function ie(i) {
+  if (Re(i))
+    throw new Error("Cannot create polygon from empty extent");
+  const t = i[0], e = i[1], n = i[2], s = i[3], r = [
+    t,
+    e,
+    t,
+    s,
+    n,
+    s,
+    n,
+    e,
+    t,
+    e
+  ];
+  return new ht(r, "XY", [r.length]);
+}
+function et(i, t) {
+  return Array.isArray(i) ? i : (t === void 0 ? t = [i, i] : (t[0] = i, t[1] = i), t);
+}
+const A = {
+  ANIMATING: 0,
+  INTERACTING: 1
+}, I = {
+  CENTER: "center",
+  RESOLUTION: "resolution",
+  ROTATION: "rotation"
+};
+function se(i, 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, s, r, o, a) {
+      if (!n)
+        return;
+      if (!s && !t)
+        return n;
+      const l = t ? 0 : r[0] * s, h = t ? 0 : r[1] * s, u = a ? a[0] : 0, c = a ? a[1] : 0;
+      let f = i[0] + l / 2 + u, g = i[2] - l / 2 + u, d = i[1] + h / 2 + c, m = i[3] - h / 2 + c;
+      f > g && (f = (g + f) / 2, g = f), d > m && (d = (m + d) / 2, m = d);
+      let _ = p(n[0], f, g), x = p(n[1], d, m);
+      if (o && e && s) {
+        const R = 30 * s;
+        _ += -R * Math.log(1 + Math.max(0, f - n[0]) / R) + R * Math.log(1 + Math.max(0, n[0] - g) / R), x += -R * Math.log(1 + Math.max(0, d - n[1]) / R) + R * Math.log(1 + Math.max(0, n[1] - m) / R);
+      }
+      return [_, x];
+    }
+  );
+}
+function Mi(i) {
+  return i;
+}
+function Ci(i) {
+  return Math.pow(i, 3);
+}
+function Ei(i) {
+  return 1 - Ci(1 - i);
+}
+function Ti(i) {
+  return 3 * i * i - 2 * i * i * i;
+}
+function Xt(i, t, e, n) {
+  const s = D(t) / e[0], r = k(t) / e[1];
+  return n ? Math.min(i, Math.max(s, r)) : Math.min(i, Math.min(s, r));
+}
+function Nt(i, t, e) {
+  let n = Math.min(i, t);
+  const s = 50;
+  return n *= Math.log(1 + s * Math.max(0, i / t - 1)) / s + 1, e && (n = Math.max(n, e), n /= Math.log(1 + s * Math.max(0, e / i - 1)) / s + 1), p(n, e / 2, t * 2);
+}
+function pi(i, 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(s, r, o, a) {
+    if (s !== void 0) {
+      const l = i[0], h = i[i.length - 1], u = e ? Xt(
+        l,
+        e,
+        o,
+        n
+      ) : l;
+      if (a)
+        return t ? Nt(
+          s,
+          u,
+          h
+        ) : p(s, h, u);
+      const c = Math.min(u, s), f = Math.floor(wt(i, c, r));
+      return i[f] > u && f < i.length - 1 ? i[f + 1] : i[f];
+    }
+  };
+}
+function Ii(i, t, e, n, s, 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, a, l, h) {
+    if (o !== void 0) {
+      const u = s ? Xt(
+        t,
+        s,
+        l,
+        r
+      ) : t;
+      if (h)
+        return n ? Nt(
+          o,
+          u,
+          e
+        ) : p(o, e, u);
+      const c = 1e-9, f = Math.ceil(
+        Math.log(t / u) / Math.log(i) - c
+      ), g = -a * (0.5 - c) + 0.5, d = Math.min(u, o), m = Math.floor(
+        Math.log(t / d) / Math.log(i) + g
+      ), _ = Math.max(f, m), x = t / Math.pow(i, _);
+      return p(x, e, u);
+    }
+  };
+}
+function re(i, t, e, n, s) {
+  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, a, l) {
+    if (r !== void 0) {
+      const h = n ? Xt(
+        i,
+        n,
+        a,
+        s
+      ) : i;
+      return !e || !l ? p(r, t, h) : Nt(
+        r,
+        h,
+        t
+      );
+    }
+  };
+}
+function yi(i) {
+  if (i !== void 0)
+    return 0;
+}
+function oe(i) {
+  if (i !== void 0)
+    return i;
+}
+function wi(i) {
+  const t = 2 * Math.PI / i;
+  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 Si(i) {
+  const t = H(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 Ze = 256, xt = 0;
+class Ai extends ce {
+  /**
+   * @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_ = vt(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 && Un(), t.center && (t.center = S(t.center, this.projection_)), t.extent && (t.extent = tt(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 a in I)
+      delete e[a];
+    this.setProperties(e, !0);
+    const n = Pi(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 s = vi(t), r = n.constraint, o = Fi(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 e = this.padding_;
+    this.padding_ = t;
+    const n = this.getCenterInternal();
+    if (n) {
+      const s = t || [0, 0, 0, 0];
+      e = e || [0, 0, 0, 0];
+      const r = this.getResolution(), o = r / 2 * (s[3] - e[3] + e[1] - s[1]), a = r / 2 * (s[0] - e[0] + e[2] - s[2]);
+      this.setCenterInternal([n[0] + o, n[1] - a]);
+    }
+  }
+  /**
+   * 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 s = arguments[n];
+      s.center && (s = Object.assign({}, s), s.center = S(
+        s.center,
+        this.getProjection()
+      )), s.anchor && (s = Object.assign({}, s), s.anchor = S(
+        s.anchor,
+        this.getProjection()
+      )), e[n] = s;
+    }
+    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 s = 0;
+    for (; s < e && !this.isDef(); ++s) {
+      const u = arguments[s];
+      u.center && this.setCenterInternal(u.center), u.zoom !== void 0 ? this.setZoom(u.zoom) : u.resolution && this.setResolution(u.resolution), u.rotation !== void 0 && this.setRotation(u.rotation);
+    }
+    if (s === e) {
+      n && nt(n, !0);
+      return;
+    }
+    let r = Date.now(), o = this.targetCenter_.slice(), a = this.targetResolution_, l = this.targetRotation_;
+    const h = [];
+    for (; s < e; ++s) {
+      const u = (
+        /** @type {AnimationOptions} */
+        arguments[s]
+      ), c = {
+        start: r,
+        complete: !1,
+        anchor: u.anchor,
+        duration: u.duration !== void 0 ? u.duration : 1e3,
+        easing: u.easing || Ti,
+        callback: n
+      };
+      if (u.center && (c.sourceCenter = o, c.targetCenter = u.center.slice(), o = c.targetCenter), u.zoom !== void 0 ? (c.sourceResolution = a, c.targetResolution = this.getResolutionForZoom(u.zoom), a = c.targetResolution) : u.resolution && (c.sourceResolution = a, c.targetResolution = u.resolution, a = c.targetResolution), u.rotation !== void 0) {
+        c.sourceRotation = l;
+        const f = bt(u.rotation - l + Math.PI, 2 * Math.PI) - Math.PI;
+        c.targetRotation = l + f, l = c.targetRotation;
+      }
+      Xi(c) ? c.complete = !0 : r += c.duration, h.push(c);
+    }
+    this.animations_.push(h), this.setHint(A.ANIMATING, 1), this.updateAnimations_();
+  }
+  /**
+   * Determine if the view is being animated.
+   * @return {boolean} The view is being animated.
+   * @api
+   */
+  getAnimating() {
+    return this.hints_[A.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_[A.INTERACTING] > 0;
+  }
+  /**
+   * Cancel any ongoing animations.
+   * @api
+   */
+  cancelAnimations() {
+    this.setHint(A.ANIMATING, -this.hints_[A.ANIMATING]);
+    let t;
+    for (let e = 0, n = this.animations_.length; e < n; ++e) {
+      const s = this.animations_[e];
+      if (s[0].callback && nt(s[0].callback, !1), !t)
+        for (let r = 0, o = s.length; r < o; ++r) {
+          const a = s[r];
+          if (!a.complete) {
+            t = a.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 s = this.animations_[n];
+      let r = !0;
+      for (let o = 0, a = s.length; o < a; ++o) {
+        const l = s[o];
+        if (l.complete)
+          continue;
+        const h = t - l.start;
+        let u = l.duration > 0 ? h / l.duration : 1;
+        u >= 1 ? (l.complete = !0, u = 1) : r = !1;
+        const c = l.easing(u);
+        if (l.sourceCenter) {
+          const f = l.sourceCenter[0], g = l.sourceCenter[1], d = l.targetCenter[0], m = l.targetCenter[1];
+          this.nextCenter_ = l.targetCenter;
+          const _ = f + c * (d - f), x = g + c * (m - g);
+          this.targetCenter_ = [_, x];
+        }
+        if (l.sourceResolution && l.targetResolution) {
+          const f = c === 1 ? l.targetResolution : l.sourceResolution + c * (l.targetResolution - l.sourceResolution);
+          if (l.anchor) {
+            const g = this.getViewportSize_(this.getRotation()), d = this.constraints_.resolution(
+              f,
+              0,
+              g,
+              !0
+            );
+            this.targetCenter_ = this.calculateCenterZoom(
+              d,
+              l.anchor
+            );
+          }
+          this.nextResolution_ = l.targetResolution, this.targetResolution_ = f, this.applyTargetState_(!0);
+        }
+        if (l.sourceRotation !== void 0 && l.targetRotation !== void 0) {
+          const f = c === 1 ? bt(l.targetRotation + Math.PI, 2 * Math.PI) - Math.PI : l.sourceRotation + c * (l.targetRotation - l.sourceRotation);
+          if (l.anchor) {
+            const g = this.constraints_.rotation(
+              f,
+              !0
+            );
+            this.targetCenter_ = this.calculateCenterRotate(
+              g,
+              l.anchor
+            );
+          }
+          this.nextRotation_ = l.targetRotation, this.targetRotation_ = f;
+        }
+        if (this.applyTargetState_(!0), e = !0, !l.complete)
+          break;
+      }
+      if (r) {
+        this.animations_[n] = null, this.setHint(A.ANIMATING, -1), this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
+        const o = s[0].callback;
+        o && nt(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 s = this.getCenterInternal();
+    return s !== void 0 && (n = [s[0] - e[0], s[1] - e[1]], Rn(n, t - this.getRotation()), _n(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 s = this.getCenterInternal(), r = this.getResolution();
+    if (s !== void 0 && r !== void 0) {
+      const o = e[0] - t * (e[0] - s[0]) / r, a = e[1] - t * (e[1] - s[1]) / r;
+      n = [o, a];
+    }
+    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], s = e[1];
+      return [
+        Math.abs(n * Math.cos(t)) + Math.abs(s * Math.sin(t)),
+        Math.abs(n * Math.sin(t)) + Math.abs(s * 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 && Kt(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 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 Hn(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()
+    );
+    y(e, "The view center is not defined");
+    const n = (
+      /** @type {!number} */
+      this.getResolution()
+    );
+    y(n !== void 0, "The view resolution is not defined");
+    const s = (
+      /** @type {!number} */
+      this.getRotation()
+    );
+    return y(s !== void 0, "The view rotation is not defined"), an(e, n, 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, e) {
+    return this.getResolutionForExtentInternal(
+      tt(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 = D(t) / e[0], s = k(t) / e[1];
+    return Math.max(n, 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 e = this.getConstrainedResolution(this.maxResolution_), n = this.minResolution_, s = Math.log(e / n) / Math.log(t);
+    return (
+      /**
+       * @param {number} value Value.
+       * @return {number} Resolution.
+       */
+      function(r) {
+        return e / 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 e = Math.log(t || 2), n = this.getConstrainedResolution(this.maxResolution_), s = this.minResolution_, r = Math.log(n / s) / 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 s = (
+      /** @type {import("./coordinate.js").Coordinate} */
+      this.getCenterInternal()
+    );
+    const r = this.padding_;
+    if (r) {
+      const o = this.getViewportSizeMinusPadding_();
+      s = Mt(
+        s,
+        this.getViewportSize_(),
+        [o[0] / 2 + r[3], o[1] / 2 + r[0]],
+        e,
+        n
+      );
+    }
+    return {
+      center: s.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, s;
+    if (this.resolutions_) {
+      const r = wt(this.resolutions_, t, 1);
+      e = r, n = this.resolutions_[r], r == this.resolutions_.length - 1 ? s = 2 : s = n / this.resolutions_[r + 1];
+    } else
+      n = this.maxResolution_, s = this.zoomFactor_;
+    return e + Math.log(n / 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_?.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 (y(
+      Array.isArray(t) || typeof /** @type {?} */
+      t.getSimplifiedGeometry == "function",
+      "Invalid extent or geometry provided as `geometry`"
+    ), Array.isArray(t)) {
+      y(
+        !Re(t),
+        "Cannot fit empty extent provided as `geometry`"
+      );
+      const s = tt(t, this.getProjection());
+      n = ie(s);
+    } else if (t.getType() === "Circle") {
+      const s = tt(
+        t.getExtent(),
+        this.getProjection()
+      );
+      n = ie(s), n.rotate(this.getRotation(), rt(s));
+    } 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), s = Math.sin(-e), r = t.getFlatCoordinates(), o = t.getStride();
+    let a = 1 / 0, l = 1 / 0, h = -1 / 0, u = -1 / 0;
+    for (let c = 0, f = r.length; c < f; c += o) {
+      const g = r[c] * n - r[c + 1] * s, d = r[c] * s + r[c + 1] * n;
+      a = Math.min(a, g), l = Math.min(l, d), h = Math.max(h, g), u = Math.max(u, d);
+    }
+    return [a, l, h, u];
+  }
+  /**
+   * @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 s = 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 a = this.rotatedExtentForGeometry(t);
+    let l = this.getResolutionForExtentInternal(a, [
+      n[0] - s[1] - s[3],
+      n[1] - s[0] - s[2]
+    ]);
+    l = isNaN(l) ? o : Math.max(l, o), l = this.getConstrainedResolution(l, r ? 0 : 1);
+    const h = this.getRotation(), u = Math.sin(h), c = Math.cos(h), f = rt(a);
+    f[0] += (s[1] - s[3]) / 2 * l, f[1] += (s[0] - s[2]) / 2 * l;
+    const g = f[0] * c - f[1] * u, d = f[1] * c + f[0] * u, m = this.getConstrainedCenter([g, d], l), _ = e.callback ? e.callback : Ct;
+    e.duration !== void 0 ? this.animateInternal(
+      {
+        resolution: l,
+        center: m,
+        duration: e.duration,
+        easing: e.easing
+      },
+      _
+    ) : (this.targetResolution_ = l, this.targetCenter_ = m, this.applyTargetState_(!1, !0), nt(_, !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(
+      S(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(
+      Mt(
+        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, s) {
+    let r;
+    const o = this.padding_;
+    if (o && t) {
+      const a = this.getViewportSizeMinusPadding_(-n), l = Mt(
+        t,
+        s,
+        [a[0] / 2 + o[3], a[1] / 2 + o[0]],
+        e,
+        n
+      );
+      r = [
+        t[0] - l[0],
+        t[1] - l[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 = Kt(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 && S(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(), s = this.getViewportSize_(this.getRotation()), r = this.constraints_.resolution(
+      this.targetResolution_ * t,
+      0,
+      s,
+      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 = S(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(), s = this.constraints_.rotation(
+      this.targetRotation_ + t,
+      n
+    );
+    e && (this.targetCenter_ = this.calculateCenterRotate(s, 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 && S(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, s = this.constraints_.rotation(
+      this.targetRotation_,
+      n
+    ), r = this.getViewportSize_(s), o = this.constraints_.resolution(
+      this.targetResolution_,
+      0,
+      r,
+      n
+    ), a = this.constraints_.center(
+      this.targetCenter_,
+      o,
+      r,
+      n,
+      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)), (!a || !this.get(I.CENTER) || !ot(this.get(I.CENTER), a)) && this.set(I.CENTER, a), 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 s = e || 0, r = this.constraints_.rotation(this.targetRotation_), o = this.getViewportSize_(r), a = this.constraints_.resolution(
+      this.targetResolution_,
+      s,
+      o
+    ), l = this.constraints_.center(
+      this.targetCenter_,
+      a,
+      o,
+      !1,
+      this.calculateCenterShift(
+        this.targetCenter_,
+        a,
+        r,
+        o
+      )
+    );
+    if (t === 0 && !this.cancelAnchor_) {
+      this.targetResolution_ = a, this.targetRotation_ = r, this.targetCenter_ = l, this.applyTargetState_();
+      return;
+    }
+    n = n || (t === 0 ? this.cancelAnchor_ : void 0), this.cancelAnchor_ = void 0, (this.getResolution() !== a || this.getRotation() !== r || !this.getCenterInternal() || !ot(this.getCenterInternal(), l)) && (this.getAnimating() && this.cancelAnimations(), this.animateInternal({
+      rotation: r,
+      center: l,
+      resolution: a,
+      duration: t,
+      easing: Ei,
+      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(A.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 && S(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(A.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 nt(i, t) {
+  setTimeout(function() {
+    i(t);
+  }, 0);
+}
+function vi(i) {
+  if (i.extent !== void 0) {
+    const e = i.smoothExtentConstraint !== void 0 ? i.smoothExtentConstraint : !0;
+    return se(i.extent, i.constrainOnlyCenter, e);
+  }
+  const t = vt(i.projection, "EPSG:3857");
+  if (i.multiWorld !== !0 && t.isGlobal()) {
+    const e = t.getExtent().slice();
+    return e[0] = -1 / 0, e[2] = 1 / 0, se(e, !1, !1);
+  }
+  return Mi;
+}
+function Pi(i) {
+  let t, e, n, o = i.minZoom !== void 0 ? i.minZoom : xt, a = i.maxZoom !== void 0 ? i.maxZoom : 28;
+  const l = i.zoomFactor !== void 0 ? i.zoomFactor : 2, h = i.multiWorld !== void 0 ? i.multiWorld : !1, u = i.smoothResolutionConstraint !== void 0 ? i.smoothResolutionConstraint : !0, c = i.showFullExtent !== void 0 ? i.showFullExtent : !1, f = vt(i.projection, "EPSG:3857"), g = f.getExtent();
+  let d = i.constrainOnlyCenter, m = i.extent;
+  if (!h && !m && f.isGlobal() && (d = !1, m = g), i.resolutions !== void 0) {
+    const _ = i.resolutions;
+    e = _[o], n = _[a] !== void 0 ? _[a] : _[_.length - 1], i.constrainResolution ? t = pi(
+      _,
+      u,
+      !d && m,
+      c
+    ) : t = re(
+      e,
+      n,
+      u,
+      !d && m,
+      c
+    );
+  } else {
+    const x = (g ? Math.max(D(g), k(g)) : (
+      // use an extent that can fit the whole world if need be
+      360 * Me.degrees / f.getMetersPerUnit()
+    )) / Ze / Math.pow(2, xt), R = x / Math.pow(2, 28 - xt);
+    e = i.maxResolution, e !== void 0 ? o = 0 : e = x / Math.pow(l, o), n = i.minResolution, n === void 0 && (i.maxZoom !== void 0 ? i.maxResolution !== void 0 ? n = e / Math.pow(l, a) : n = x / Math.pow(l, a) : n = R), a = o + Math.floor(
+      Math.log(e / n) / Math.log(l)
+    ), n = e / Math.pow(l, a - o), i.constrainResolution ? t = Ii(
+      l,
+      e,
+      n,
+      u,
+      !d && m,
+      c
+    ) : t = re(
+      e,
+      n,
+      u,
+      !d && m,
+      c
+    );
+  }
+  return {
+    constraint: t,
+    maxResolution: e,
+    minResolution: n,
+    minZoom: o,
+    zoomFactor: l
+  };
+}
+function Fi(i) {
+  if (i.enableRotation !== void 0 ? i.enableRotation : !0) {
+    const e = i.constrainRotation;
+    return e === void 0 || e === !0 ? Si() : e === !1 ? oe : typeof e == "number" ? wi(e) : oe;
+  }
+  return yi;
+}
+function Xi(i) {
+  return !(i.sourceCenter && i.targetCenter && !ot(i.sourceCenter, i.targetCenter) || i.sourceResolution !== i.targetResolution || i.sourceRotation !== i.targetRotation);
+}
+function Mt(i, t, e, n, s) {
+  const r = Math.cos(-s);
+  let o = Math.sin(-s), a = i[0] * r - i[1] * o, l = i[1] * r + i[0] * o;
+  a += (t[0] / 2 - e[0]) * n, l += (e[1] - t[1] / 2) * n, o = -o;
+  const h = a * r - l * o, u = l * r + a * o;
+  return [h, u];
+}
+class je {
+  /**
+   * @param {number} minX Minimum X.
+   * @param {number} maxX Maximum X.
+   * @param {number} minY Minimum Y.
+   * @param {number} maxY Maximum Y.
+   */
+  constructor(t, e, n, s) {
+    this.minX = t, this.maxX = e, this.minY = n, this.maxY = s;
+  }
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {boolean} Contains tile coordinate.
+   */
+  contains(t) {
+    return this.containsXY(t[1], t[2]);
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Contains.
+   */
+  containsTileRange(t) {
+    return this.minX <= t.minX && t.maxX <= this.maxX && this.minY <= t.minY && t.maxY <= this.maxY;
+  }
+  /**
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @return {boolean} Contains coordinate.
+   */
+  containsXY(t, e) {
+    return this.minX <= t && t <= this.maxX && this.minY <= e && e <= this.maxY;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Equals.
+   */
+  equals(t) {
+    return this.minX == t.minX && this.minY == t.minY && this.maxX == t.maxX && this.maxY == t.maxY;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   */
+  extend(t) {
+    t.minX < this.minX && (this.minX = t.minX), t.maxX > this.maxX && (this.maxX = t.maxX), t.minY < this.minY && (this.minY = t.minY), t.maxY > this.maxY && (this.maxY = t.maxY);
+  }
+  /**
+   * @return {number} Height.
+   */
+  getHeight() {
+    return this.maxY - this.minY + 1;
+  }
+  /**
+   * @return {import("./size.js").Size} Size.
+   */
+  getSize() {
+    return [this.getWidth(), this.getHeight()];
+  }
+  /**
+   * @return {number} Width.
+   */
+  getWidth() {
+    return this.maxX - this.minX + 1;
+  }
+  /**
+   * @param {TileRange} tileRange Tile range.
+   * @return {boolean} Intersects.
+   */
+  intersects(t) {
+    return this.minX <= t.maxX && this.maxX >= t.minX && this.minY <= t.maxY && this.maxY >= t.minY;
+  }
+}
+function O(i, t, e, n, s) {
+  return s !== void 0 ? (s.minX = i, s.maxX = t, s.minY = e, s.maxY = n, s) : new je(i, t, e, n);
+}
+function Ni(i) {
+  const t = Object.keys(i.defs), e = t.length;
+  let n, s;
+  for (n = 0; n < e; ++n) {
+    const r = t[n];
+    if (!it(r)) {
+      const o = i.defs(r);
+      let a = (
+        /** @type {import("./Units.js").Units} */
+        o.units
+      );
+      !a && o.projName === "longlat" && (a = "degrees"), ut(
+        new ft({
+          code: r,
+          axisOrientation: o.axis,
+          metersPerUnit: o.to_meter,
+          units: a
+        })
+      );
+    }
+  }
+  for (n = 0; n < e; ++n) {
+    const r = t[n], o = it(r);
+    for (s = 0; s < e; ++s) {
+      const a = t[s], l = it(a);
+      if (!st(r, a))
+        if (i.defs[r] === i.defs[a])
+          yt([o, l]);
+        else {
+          const h = i(r, a);
+          Wn(
+            o,
+            l,
+            Jt(o, l, h.forward),
+            Jt(l, o, h.inverse)
+          );
+        }
+    }
+  }
+}
+function ae(i, t, e, n) {
+  return n !== void 0 ? (n[0] = i, n[1] = t, n[2] = e, n) : [i, t, e];
+}
+const L = [0, 0, 0], v = 5;
+class Yi {
+  /**
+   * @param {Options} options Tile grid options.
+   */
+  constructor(t) {
+    this.minZoom = t.minZoom !== void 0 ? t.minZoom : 0, this.resolutions_ = t.resolutions, y(
+      We(
+        this.resolutions_,
+        /**
+         * @param {number} a First resolution
+         * @param {number} b Second resolution
+         * @return {number} Comparison result
+         */
+        (s, r) => r - s
+      ),
+      "`resolutions` must be sorted in descending order"
+    );
+    let e;
+    if (!t.origins) {
+      for (let s = 0, r = this.resolutions_.length - 1; s < r; ++s)
+        if (!e)
+          e = this.resolutions_[s] / this.resolutions_[s + 1];
+        else if (this.resolutions_[s] / this.resolutions_[s + 1] !== e) {
+          e = void 0;
+          break;
+        }
+    }
+    this.zoomFactor_ = e, this.maxZoom = this.resolutions_.length - 1, this.origin_ = t.origin !== void 0 ? t.origin : null, this.origins_ = null, t.origins !== void 0 && (this.origins_ = t.origins, y(
+      this.origins_.length == this.resolutions_.length,
+      "Number of `origins` and `resolutions` must be equal"
+    ));
+    const n = t.extent;
+    n !== void 0 && !this.origin_ && !this.origins_ && (this.origin_ = _e(n)), y(
+      !this.origin_ && this.origins_ || this.origin_ && !this.origins_,
+      "Either `origin` or `origins` must be configured, never both"
+    ), this.tileSizes_ = null, t.tileSizes !== void 0 && (this.tileSizes_ = t.tileSizes, y(
+      this.tileSizes_.length == this.resolutions_.length,
+      "Number of `tileSizes` and `resolutions` must be equal"
+    )), this.tileSize_ = t.tileSize !== void 0 ? t.tileSize : this.tileSizes_ ? null : Ze, y(
+      !this.tileSize_ && this.tileSizes_ || this.tileSize_ && !this.tileSizes_,
+      "Either `tileSize` or `tileSizes` must be configured, never both"
+    ), this.extent_ = n !== void 0 ? n : null, this.fullTileRanges_ = null, this.tmpSize_ = [0, 0], this.tmpExtent_ = [0, 0, 0, 0], t.sizes !== void 0 ? this.fullTileRanges_ = t.sizes.map((s, r) => {
+      const o = new je(
+        Math.min(0, s[0]),
+        Math.max(s[0] - 1, -1),
+        Math.min(0, s[1]),
+        Math.max(s[1] - 1, -1)
+      );
+      if (n) {
+        const a = this.getTileRangeForExtentAndZ(n, r);
+        o.minX = Math.max(a.minX, o.minX), o.maxX = Math.min(a.maxX, o.maxX), o.minY = Math.max(a.minY, o.minY), o.maxY = Math.min(a.maxY, o.maxY);
+      }
+      return o;
+    }) : n && this.calculateTileRanges_(n);
+  }
+  /**
+   * Call a function with each tile coordinate for a given extent and zoom level.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} zoom Integer zoom level.
+   * @param {function(import("../tilecoord.js").TileCoord): void} callback Function called with each tile coordinate.
+   * @api
+   */
+  forEachTileCoord(t, e, n) {
+    const s = this.getTileRangeForExtentAndZ(t, e);
+    for (let r = s.minX, o = s.maxX; r <= o; ++r)
+      for (let a = s.minY, l = s.maxY; a <= l; ++a)
+        n([e, r, a]);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {function(number, import("../TileRange.js").default): boolean} callback Callback.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {boolean} Callback succeeded.
+   */
+  forEachTileCoordParentTileRange(t, e, n, s) {
+    let r, o, a, l = null, h = t[0] - 1;
+    for (this.zoomFactor_ === 2 ? (o = t[1], a = t[2]) : l = this.getTileCoordExtent(t, s); h >= this.minZoom; ) {
+      if (o !== void 0 && a !== void 0 ? (o = Math.floor(o / 2), a = Math.floor(a / 2), r = O(o, o, a, a, n)) : r = this.getTileRangeForExtentAndZ(
+        l,
+        h,
+        n
+      ), e(h, r))
+        return !0;
+      --h;
+    }
+    return !1;
+  }
+  /**
+   * Get the extent for this tile grid, if it was configured.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the maximum zoom level for the grid.
+   * @return {number} Max zoom.
+   * @api
+   */
+  getMaxZoom() {
+    return this.maxZoom;
+  }
+  /**
+   * Get the minimum zoom level for the grid.
+   * @return {number} Min zoom.
+   * @api
+   */
+  getMinZoom() {
+    return this.minZoom;
+  }
+  /**
+   * Get the origin for the grid at the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {import("../coordinate.js").Coordinate} Origin.
+   * @api
+   */
+  getOrigin(t) {
+    return this.origin_ ? this.origin_ : this.origins_[t];
+  }
+  /**
+   * Get the resolution for the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {number} Resolution.
+   * @api
+   */
+  getResolution(t) {
+    return this.resolutions_[t];
+  }
+  /**
+   * Get the list of resolutions for the tile grid.
+   * @return {Array<number>} Resolutions.
+   * @api
+   */
+  getResolutions() {
+    return this.resolutions_;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileCoordChildTileRange(t, e, n) {
+    if (t[0] < this.maxZoom) {
+      if (this.zoomFactor_ === 2) {
+        const r = t[1] * 2, o = t[2] * 2;
+        return O(
+          r,
+          r + 1,
+          o,
+          o + 1,
+          e
+        );
+      }
+      const s = this.getTileCoordExtent(
+        t,
+        n || this.tmpExtent_
+      );
+      return this.getTileRangeForExtentAndZ(
+        s,
+        t[0] + 1,
+        e
+      );
+    }
+    return null;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileRangeForTileCoordAndZ(t, e, n) {
+    if (e > this.maxZoom || e < this.minZoom)
+      return null;
+    const s = t[0], r = t[1], o = t[2];
+    if (e === s)
+      return O(
+        r,
+        o,
+        r,
+        o,
+        n
+      );
+    if (this.zoomFactor_) {
+      const l = Math.pow(this.zoomFactor_, e - s), h = Math.floor(r * l), u = Math.floor(o * l);
+      if (e < s)
+        return O(h, h, u, u, n);
+      const c = Math.floor(l * (r + 1)) - 1, f = Math.floor(l * (o + 1)) - 1;
+      return O(h, c, u, f, n);
+    }
+    const a = this.getTileCoordExtent(t, this.tmpExtent_);
+    return this.getTileRangeForExtentAndZ(a, e, n);
+  }
+  /**
+   * Get a tile range for the given extent and integer zoom level.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary tile range object.
+   * @return {import("../TileRange.js").default} Tile range.
+   */
+  getTileRangeForExtentAndZ(t, e, n) {
+    this.getTileCoordForXYAndZ_(t[0], t[3], e, !1, L);
+    const s = L[1], r = L[2];
+    this.getTileCoordForXYAndZ_(t[2], t[1], e, !0, L);
+    const o = L[1], a = L[2];
+    return O(s, o, r, a, n);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {import("../coordinate.js").Coordinate} Tile center.
+   */
+  getTileCoordCenter(t) {
+    const e = this.getOrigin(t[0]), n = this.getResolution(t[0]), s = et(this.getTileSize(t[0]), this.tmpSize_);
+    return [
+      e[0] + (t[1] + 0.5) * s[0] * n,
+      e[1] - (t[2] + 0.5) * s[1] * n
+    ];
+  }
+  /**
+   * Get the extent of a tile coordinate.
+   *
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary extent object.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getTileCoordExtent(t, e) {
+    const n = this.getOrigin(t[0]), s = this.getResolution(t[0]), r = et(this.getTileSize(t[0]), this.tmpSize_), o = n[0] + t[1] * r[0] * s, a = n[1] - (t[2] + 1) * r[1] * s, l = o + r[0] * s, h = a + r[1] * s;
+    return ct(o, a, l, h, e);
+  }
+  /**
+   * Get the tile coordinate for the given map coordinate and resolution.  This
+   * method considers that coordinates that intersect tile boundaries should be
+   * assigned the higher tile coordinate.
+   *
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} resolution Resolution.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndResolution(t, e, n) {
+    return this.getTileCoordForXYAndResolution_(
+      t[0],
+      t[1],
+      e,
+      !1,
+      n
+    );
+  }
+  /**
+   * Note that this method should not be called for resolutions that correspond
+   * to an integer zoom level.  Instead call the `getTileCoordForXYAndZ_` method.
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {number} resolution Resolution (for a non-integer zoom level).
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndResolution_(t, e, n, s, r) {
+    const o = this.getZForResolution(n), a = n / this.getResolution(o), l = this.getOrigin(o), h = et(this.getTileSize(o), this.tmpSize_);
+    let u = a * (t - l[0]) / n / h[0], c = a * (l[1] - e) / n / h[1];
+    return s ? (u = J(u, v) - 1, c = J(c, v) - 1) : (u = K(u, v), c = K(c, v)), ae(o, u, c, r);
+  }
+  /**
+   * Although there is repetition between this method and `getTileCoordForXYAndResolution_`,
+   * they should have separate implementations.  This method is for integer zoom
+   * levels.  The other method should only be called for resolutions corresponding
+   * to non-integer zoom levels.
+   * @param {number} x Map x coordinate.
+   * @param {number} y Map y coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndZ_(t, e, n, s, r) {
+    const o = this.getOrigin(n), a = this.getResolution(n), l = et(this.getTileSize(n), this.tmpSize_);
+    let h = (t - o[0]) / a / l[0], u = (o[1] - e) / a / l[1];
+    return s ? (h = J(h, v) - 1, u = J(u, v) - 1) : (h = K(h, v), u = K(u, v)), ae(n, h, u, r);
+  }
+  /**
+   * Get a tile coordinate given a map coordinate and zoom level.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} z Integer zoom level, e.g. the result of a `getZForResolution()` method call
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndZ(t, e, n) {
+    return this.getTileCoordForXYAndZ_(
+      t[0],
+      t[1],
+      e,
+      !1,
+      n
+    );
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {number} Tile resolution.
+   */
+  getTileCoordResolution(t) {
+    return this.resolutions_[t[0]];
+  }
+  /**
+   * Get the tile size for a zoom level. The type of the return value matches the
+   * `tileSize` or `tileSizes` that the tile grid was configured with. To always
+   * get an {@link import("../size.js").Size}, run the result through {@link module:ol/size.toSize}.
+   * @param {number} z Z.
+   * @return {number|import("../size.js").Size} Tile size.
+   * @api
+   */
+  getTileSize(t) {
+    return this.tileSize_ ? this.tileSize_ : this.tileSizes_[t];
+  }
+  /**
+   * @param {number} z Zoom level.
+   * @return {import("../TileRange.js").default|null} Extent tile range for the specified zoom level.
+   */
+  getFullTileRange(t) {
+    return this.fullTileRanges_ ? this.fullTileRanges_[t] : this.extent_ ? this.getTileRangeForExtentAndZ(this.extent_, t) : null;
+  }
+  /**
+   * @param {number} resolution Resolution.
+   * @param {number|import("../array.js").NearestDirectionFunction} [opt_direction]
+   *     If 0, the nearest resolution will be used.
+   *     If 1, the nearest higher resolution (lower Z) will be used. If -1, the
+   *     nearest lower resolution (higher Z) will be used. Default is 0.
+   *     Use a {@link module:ol/array~NearestDirectionFunction} for more precise control.
+   *
+   * For example to change tile Z at the midpoint of zoom levels
+   * ```js
+   * function(value, high, low) {
+   *   return value - low * Math.sqrt(high / low);
+   * }
+   * ```
+   * @return {number} Z.
+   * @api
+   */
+  getZForResolution(t, e) {
+    const n = wt(
+      this.resolutions_,
+      t,
+      e || 0
+    );
+    return p(n, this.minZoom, this.maxZoom);
+  }
+  /**
+   * The tile with the provided tile coordinate intersects the given viewport.
+   * @param {import('../tilecoord.js').TileCoord} tileCoord Tile coordinate.
+   * @param {Array<number>} viewport Viewport as returned from {@link module:ol/extent.getRotatedViewport}.
+   * @return {boolean} The tile with the provided tile coordinate intersects the given viewport.
+   */
+  tileCoordIntersectsViewport(t, e) {
+    return Ne(
+      e,
+      0,
+      e.length,
+      2,
+      this.getTileCoordExtent(t)
+    );
+  }
+  /**
+   * @param {!import("../extent.js").Extent} extent Extent for this tile grid.
+   * @private
+   */
+  calculateTileRanges_(t) {
+    const e = this.resolutions_.length, n = new Array(e);
+    for (let s = this.minZoom; s < e; ++s)
+      n[s] = this.getTileRangeForExtentAndZ(t, s);
+    this.fullTileRanges_ = n;
+  }
+}
+class Zi extends Yi {
+  /**
+   * @param {Options} options WMTS options.
+   */
+  constructor(t) {
+    super({
+      extent: t.extent,
+      origin: t.origin,
+      origins: t.origins,
+      resolutions: t.resolutions,
+      tileSize: t.tileSize,
+      tileSizes: t.tileSizes,
+      sizes: t.sizes
+    }), this.matrixIds_ = t.matrixIds;
+  }
+  /**
+   * @param {number} z Z.
+   * @return {string} MatrixId..
+   */
+  getMatrixId(t) {
+    return this.matrixIds_[t];
+  }
+  /**
+   * Get the list of matrix identifiers.
+   * @return {Array<string>} MatrixIds.
+   * @api
+   */
+  getMatrixIds() {
+    return this.matrixIds_;
+  }
+}
+function Gi(i) {
+  Oe(i), Ni(i);
+}
+function ji(i) {
+  const t = P.getResolutionSteps(), e = t.find(
+    (n) => n.resolution === i
+  );
+  return e ? t.indexOf(e) : t.length - 1;
+}
+function Oi(i = 0.25) {
+  const t = ji(i);
+  let e = P.getResolutionSteps();
+  return e.length > t && (e = e.slice(0, t + 1)), new Zi({
+    resolutions: e.map((n) => n.resolution),
+    origin: P.getTileOrigin(),
+    matrixIds: e.map((n, s) => s.toString()),
+    extent: P.bounds?.flatten
+  });
+}
+function Li() {
+  return new Ai({
+    projection: P.epsg,
+    center: P.bounds.center,
+    zoom: P.getDefaultZoom(),
+    minResolution: _t[_t.length - 1],
+    resolutions: _t,
+    extent: P.bounds.flatten,
+    constrainOnlyCenter: !0
+  });
+}
+export {
+  Oi as getLV95TileGrid,
+  Li as getLV95View,
+  Gi as registerSwissGeoProjections
+};