gisviewer-vue3-arcgis 1.0.283 → 1.0.284

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/View.mjs

@@ -1,1170 +0,0 @@
-import G from "./Object.mjs";
-import C from "./ViewHint.mjs";
-import _ from "./ViewProperty.mjs";
-import { linearFindNearest as U } from "./array.mjs";
-import { assert as I } from "./asserts.mjs";
-import { createExtent as y, none as k } from "./centerconstraint.mjs";
-import { rotate as H, add as D, equals as Z } from "./coordinate.mjs";
-import { inAndOut as L, easeOut as X } from "./easing.mjs";
-import { getForViewAndSize as Y, getWidth as O, getHeight as V, isEmpty as K, getCenter as T } from "./extent.mjs";
-import { VOID as W } from "./functions.mjs";
-import { fromExtent as z } from "./geom/Polygon.mjs";
-import { modulo as F, clamp as E } from "./math.mjs";
-import { createProjection as j, fromUserCoordinate as x, fromUserExtent as M, toUserCoordinate as N, toUserExtent as q, disableCoordinateWarning as B } from "./proj.mjs";
-import { createSnapToResolutions as $, createMinMaxResolution as P, createSnapToPower as J } from "./resolutionconstraint.mjs";
-import { createSnapToZero as Q, none as b, createSnapToN as tt, disable as et } from "./rotationconstraint.mjs";
-import { DEFAULT_TILE_SIZE as nt } from "./tilegrid/common.mjs";
-import { METERS_PER_UNIT as it } from "./proj/Units.mjs";
-const w = 0;
-class ot extends G {
-  /**
-   * @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_ = j(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 && B(), t.center && (t.center = x(t.center, this.projection_)), t.extent && (t.extent = M(t.extent, this.projection_)), this.applyOptions_(t);
-  }
-  /**
-   * Set up the view with the given options.
-   * @param {ViewOptions} options View options.
-   */
-  applyOptions_(t) {
-    const e = Object.assign({}, t);
-    for (const l in _)
-      delete e[l];
-    this.setProperties(e, !0);
-    const n = rt(t);
-    this.maxResolution_ = n.maxResolution, this.minResolution_ = n.minResolution, this.zoomFactor_ = n.zoomFactor, this.resolutions_ = t.resolutions, this.padding_ = t.padding, this.minZoom_ = n.minZoom;
-    const i = st(t), s = n.constraint, r = at(t);
-    this.constraints_ = {
-      center: i,
-      resolution: s,
-      rotation: r
-    }, this.setRotation(t.rotation !== void 0 ? t.rotation : 0), this.setCenterInternal(
-      t.center !== void 0 ? t.center : null
-    ), t.resolution !== void 0 ? this.setResolution(t.resolution) : t.zoom !== void 0 && this.setZoom(t.zoom);
-  }
-  /**
-   * Padding (in css pixels).
-   * If the map viewport is partially covered with other content (overlays) along
-   * its edges, this setting allows to shift the center of the viewport away from that
-   * content. The order of the values in the array is top, right, bottom, left.
-   * The default is no padding, which is equivalent to `[0, 0, 0, 0]`.
-   * @type {Array<number>|undefined}
-   * @api
-   */
-  get padding() {
-    return this.padding_;
-  }
-  set padding(t) {
-    let e = this.padding_;
-    this.padding_ = t;
-    const n = this.getCenterInternal();
-    if (n) {
-      const i = t || [0, 0, 0, 0];
-      e = e || [0, 0, 0, 0];
-      const s = this.getResolution(), r = s / 2 * (i[3] - e[3] + e[1] - i[1]), l = s / 2 * (i[0] - e[0] + e[2] - i[2]);
-      this.setCenterInternal([n[0] + r, n[1] - l]);
-    }
-  }
-  /**
-   * Get an updated version of the view options used to construct the view.  The
-   * current resolution (or zoom), center, and rotation are applied to any stored
-   * options.  The provided options can be used to apply new min/max zoom or
-   * resolution limits.
-   * @param {ViewOptions} newOptions New options to be applied.
-   * @return {ViewOptions} New options updated with the current view state.
-   */
-  getUpdatedOptions_(t) {
-    const e = this.getProperties();
-    return e.resolution !== void 0 ? e.resolution = this.getResolution() : e.zoom = this.getZoom(), e.center = this.getCenterInternal(), e.rotation = this.getRotation(), Object.assign({}, e, t);
-  }
-  /**
-   * Animate the view.  The view's center, zoom (or resolution), and rotation
-   * can be animated for smooth transitions between view states.  For example,
-   * to animate the view to a new zoom level:
-   *
-   *     view.animate({zoom: view.getZoom() + 1});
-   *
-   * By default, the animation lasts one second and uses in-and-out easing.  You
-   * can customize this behavior by including `duration` (in milliseconds) and
-   * `easing` options (see {@link module:ol/easing}).
-   *
-   * To chain together multiple animations, call the method with multiple
-   * animation objects.  For example, to first zoom and then pan:
-   *
-   *     view.animate({zoom: 10}, {center: [0, 0]});
-   *
-   * If you provide a function as the last argument to the animate method, it
-   * will get called at the end of an animation series.  The callback will be
-   * called with `true` if the animation series completed on its own or `false`
-   * if it was cancelled.
-   *
-   * Animations are cancelled by user interactions (e.g. dragging the map) or by
-   * calling `view.setCenter()`, `view.setResolution()`, or `view.setRotation()`
-   * (or another method that calls one of these).
-   *
-   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation
-   *     options.  Multiple animations can be run in series by passing multiple
-   *     options objects.  To run multiple animations in parallel, call the method
-   *     multiple times.  An optional callback can be provided as a final
-   *     argument.  The callback will be called with a boolean indicating whether
-   *     the animation completed without being cancelled.
-   * @api
-   */
-  animate(t) {
-    this.isDef() && !this.getAnimating() && this.resolveConstraints(0);
-    const e = new Array(arguments.length);
-    for (let n = 0; n < e.length; ++n) {
-      let i = arguments[n];
-      i.center && (i = Object.assign({}, i), i.center = x(
-        i.center,
-        this.getProjection()
-      )), i.anchor && (i = Object.assign({}, i), i.anchor = x(
-        i.anchor,
-        this.getProjection()
-      )), e[n] = i;
-    }
-    this.animateInternal.apply(this, e);
-  }
-  /**
-   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation options.
-   */
-  animateInternal(t) {
-    let e = arguments.length, n;
-    e > 1 && typeof arguments[e - 1] == "function" && (n = arguments[e - 1], --e);
-    let i = 0;
-    for (; i < e && !this.isDef(); ++i) {
-      const u = arguments[i];
-      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 (i === e) {
-      n && A(n, !0);
-      return;
-    }
-    let s = Date.now(), r = this.targetCenter_.slice(), l = this.targetResolution_, o = this.targetRotation_;
-    const d = [];
-    for (; i < e; ++i) {
-      const u = (
-        /** @type {AnimationOptions} */
-        arguments[i]
-      ), h = {
-        start: s,
-        complete: !1,
-        anchor: u.anchor,
-        duration: u.duration !== void 0 ? u.duration : 1e3,
-        easing: u.easing || L,
-        callback: n
-      };
-      if (u.center && (h.sourceCenter = r, h.targetCenter = u.center.slice(), r = h.targetCenter), u.zoom !== void 0 ? (h.sourceResolution = l, h.targetResolution = this.getResolutionForZoom(u.zoom), l = h.targetResolution) : u.resolution && (h.sourceResolution = l, h.targetResolution = u.resolution, l = h.targetResolution), u.rotation !== void 0) {
-        h.sourceRotation = o;
-        const c = F(u.rotation - o + Math.PI, 2 * Math.PI) - Math.PI;
-        h.targetRotation = o + c, o = h.targetRotation;
-      }
-      lt(h) ? h.complete = !0 : s += h.duration, d.push(h);
-    }
-    this.animations_.push(d), this.setHint(C.ANIMATING, 1), this.updateAnimations_();
-  }
-  /**
-   * Determine if the view is being animated.
-   * @return {boolean} The view is being animated.
-   * @api
-   */
-  getAnimating() {
-    return this.hints_[C.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_[C.INTERACTING] > 0;
-  }
-  /**
-   * Cancel any ongoing animations.
-   * @api
-   */
-  cancelAnimations() {
-    this.setHint(C.ANIMATING, -this.hints_[C.ANIMATING]);
-    let t;
-    for (let e = 0, n = this.animations_.length; e < n; ++e) {
-      const i = this.animations_[e];
-      if (i[0].callback && A(i[0].callback, !1), !t)
-        for (let s = 0, r = i.length; s < r; ++s) {
-          const l = i[s];
-          if (!l.complete) {
-            t = l.anchor;
-            break;
-          }
-        }
-    }
-    this.animations_.length = 0, this.cancelAnchor_ = t, this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
-  }
-  /**
-   * Update all animations.
-   */
-  updateAnimations_() {
-    if (this.updateAnimationKey_ !== void 0 && (cancelAnimationFrame(this.updateAnimationKey_), this.updateAnimationKey_ = void 0), !this.getAnimating())
-      return;
-    const t = Date.now();
-    let e = !1;
-    for (let n = this.animations_.length - 1; n >= 0; --n) {
-      const i = this.animations_[n];
-      let s = !0;
-      for (let r = 0, l = i.length; r < l; ++r) {
-        const o = i[r];
-        if (o.complete)
-          continue;
-        const d = t - o.start;
-        let u = o.duration > 0 ? d / o.duration : 1;
-        u >= 1 ? (o.complete = !0, u = 1) : s = !1;
-        const h = o.easing(u);
-        if (o.sourceCenter) {
-          const c = o.sourceCenter[0], g = o.sourceCenter[1], f = o.targetCenter[0], R = o.targetCenter[1];
-          this.nextCenter_ = o.targetCenter;
-          const m = c + h * (f - c), p = g + h * (R - g);
-          this.targetCenter_ = [m, p];
-        }
-        if (o.sourceResolution && o.targetResolution) {
-          const c = h === 1 ? o.targetResolution : o.sourceResolution + h * (o.targetResolution - o.sourceResolution);
-          if (o.anchor) {
-            const g = this.getViewportSize_(this.getRotation()), f = this.constraints_.resolution(
-              c,
-              0,
-              g,
-              !0
-            );
-            this.targetCenter_ = this.calculateCenterZoom(
-              f,
-              o.anchor
-            );
-          }
-          this.nextResolution_ = o.targetResolution, this.targetResolution_ = c, this.applyTargetState_(!0);
-        }
-        if (o.sourceRotation !== void 0 && o.targetRotation !== void 0) {
-          const c = h === 1 ? F(o.targetRotation + Math.PI, 2 * Math.PI) - Math.PI : o.sourceRotation + h * (o.targetRotation - o.sourceRotation);
-          if (o.anchor) {
-            const g = this.constraints_.rotation(
-              c,
-              !0
-            );
-            this.targetCenter_ = this.calculateCenterRotate(
-              g,
-              o.anchor
-            );
-          }
-          this.nextRotation_ = o.targetRotation, this.targetRotation_ = c;
-        }
-        if (this.applyTargetState_(!0), e = !0, !o.complete)
-          break;
-      }
-      if (s) {
-        this.animations_[n] = null, this.setHint(C.ANIMATING, -1), this.nextCenter_ = null, this.nextResolution_ = NaN, this.nextRotation_ = NaN;
-        const r = i[0].callback;
-        r && A(r, !0);
-      }
-    }
-    this.animations_ = this.animations_.filter(Boolean), e && this.updateAnimationKey_ === void 0 && (this.updateAnimationKey_ = requestAnimationFrame(
-      this.updateAnimations_.bind(this)
-    ));
-  }
-  /**
-   * @param {number} rotation Target rotation.
-   * @param {import("./coordinate.js").Coordinate} anchor Rotation anchor.
-   * @return {import("./coordinate.js").Coordinate|undefined} Center for rotation and anchor.
-   */
-  calculateCenterRotate(t, e) {
-    let n;
-    const i = this.getCenterInternal();
-    return i !== void 0 && (n = [i[0] - e[0], i[1] - e[1]], H(n, t - this.getRotation()), D(n, e)), n;
-  }
-  /**
-   * @param {number} resolution Target resolution.
-   * @param {import("./coordinate.js").Coordinate} anchor Zoom anchor.
-   * @return {import("./coordinate.js").Coordinate|undefined} Center for resolution and anchor.
-   */
-  calculateCenterZoom(t, e) {
-    let n;
-    const i = this.getCenterInternal(), s = this.getResolution();
-    if (i !== void 0 && s !== void 0) {
-      const r = e[0] - t * (e[0] - i[0]) / s, l = e[1] - t * (e[1] - i[1]) / s;
-      n = [r, l];
-    }
-    return n;
-  }
-  /**
-   * Returns the current viewport size.
-   * @private
-   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
-   * @return {import("./size.js").Size} Viewport size or `[100, 100]` when no viewport is found.
-   */
-  getViewportSize_(t) {
-    const e = this.viewportSize_;
-    if (t) {
-      const n = e[0], i = e[1];
-      return [
-        Math.abs(n * Math.cos(t)) + Math.abs(i * Math.sin(t)),
-        Math.abs(n * Math.sin(t)) + Math.abs(i * Math.cos(t))
-      ];
-    }
-    return e;
-  }
-  /**
-   * Stores the viewport size on the view. The viewport size is not read every time from the DOM
-   * to avoid performance hit and layout reflow.
-   * This should be done on map size change.
-   * Note: the constraints are not resolved during an animation to avoid stopping it
-   * @param {import("./size.js").Size} [size] Viewport size; if undefined, [100, 100] is assumed
-   */
-  setViewportSize(t) {
-    this.viewportSize_ = Array.isArray(t) ? t.slice() : [100, 100], this.getAnimating() || this.resolveConstraints(0);
-  }
-  /**
-   * Get the view center.
-   * @return {import("./coordinate.js").Coordinate|undefined} The center of the view.
-   * @observable
-   * @api
-   */
-  getCenter() {
-    const t = this.getCenterInternal();
-    return t && N(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(_.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 q(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()
-    );
-    I(e, "The view center is not defined");
-    const n = (
-      /** @type {!number} */
-      this.getResolution()
-    );
-    I(n !== void 0, "The view resolution is not defined");
-    const i = (
-      /** @type {!number} */
-      this.getRotation()
-    );
-    return I(i !== void 0, "The view rotation is not defined"), Y(e, n, i, t);
-  }
-  /**
-   * Get the maximum resolution of the view.
-   * @return {number} The maximum resolution of the view.
-   * @api
-   */
-  getMaxResolution() {
-    return this.maxResolution_;
-  }
-  /**
-   * Get the minimum resolution of the view.
-   * @return {number} The minimum resolution of the view.
-   * @api
-   */
-  getMinResolution() {
-    return this.minResolution_;
-  }
-  /**
-   * Get the maximum zoom level for the view.
-   * @return {number} The maximum zoom level.
-   * @api
-   */
-  getMaxZoom() {
-    return (
-      /** @type {number} */
-      this.getZoomForResolution(this.minResolution_)
-    );
-  }
-  /**
-   * Set a new maximum zoom level for the view.
-   * @param {number} zoom The maximum zoom level.
-   * @api
-   */
-  setMaxZoom(t) {
-    this.applyOptions_(this.getUpdatedOptions_({ maxZoom: t }));
-  }
-  /**
-   * Get the minimum zoom level for the view.
-   * @return {number} The minimum zoom level.
-   * @api
-   */
-  getMinZoom() {
-    return (
-      /** @type {number} */
-      this.getZoomForResolution(this.maxResolution_)
-    );
-  }
-  /**
-   * Set a new minimum zoom level for the view.
-   * @param {number} zoom The minimum zoom level.
-   * @api
-   */
-  setMinZoom(t) {
-    this.applyOptions_(this.getUpdatedOptions_({ minZoom: t }));
-  }
-  /**
-   * Set whether the view should allow intermediary zoom levels.
-   * @param {boolean} enabled Whether the resolution is constrained.
-   * @api
-   */
-  setConstrainResolution(t) {
-    this.applyOptions_(this.getUpdatedOptions_({ constrainResolution: t }));
-  }
-  /**
-   * Get the view projection.
-   * @return {import("./proj/Projection.js").default} The projection of the view.
-   * @api
-   */
-  getProjection() {
-    return this.projection_;
-  }
-  /**
-   * Get the view resolution.
-   * @return {number|undefined} The resolution of the view.
-   * @observable
-   * @api
-   */
-  getResolution() {
-    return (
-      /** @type {number|undefined} */
-      this.get(_.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(
-      M(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 = O(t) / e[0], i = V(t) / e[1];
-    return Math.max(n, i);
-  }
-  /**
-   * Return a function that returns a value between 0 and 1 for a
-   * resolution. Exponential scaling is assumed.
-   * @param {number} [power] Power.
-   * @return {function(number): number} Resolution for value function.
-   */
-  getResolutionForValueFunction(t) {
-    t = t || 2;
-    const e = this.getConstrainedResolution(this.maxResolution_), n = this.minResolution_, i = Math.log(e / n) / Math.log(t);
-    return (
-      /**
-       * @param {number} value Value.
-       * @return {number} Resolution.
-       */
-      function(s) {
-        return e / Math.pow(t, s * i);
-      }
-    );
-  }
-  /**
-   * Get the view rotation.
-   * @return {number} The rotation of the view in radians.
-   * @observable
-   * @api
-   */
-  getRotation() {
-    return (
-      /** @type {number} */
-      this.get(_.ROTATION)
-    );
-  }
-  /**
-   * Return a function that returns a resolution for a value between
-   * 0 and 1. Exponential scaling is assumed.
-   * @param {number} [power] Power.
-   * @return {function(number): number} Value for resolution function.
-   */
-  getValueForResolutionFunction(t) {
-    const e = Math.log(t || 2), n = this.getConstrainedResolution(this.maxResolution_), i = this.minResolution_, s = Math.log(n / i) / e;
-    return (
-      /**
-       * @param {number} resolution Resolution.
-       * @return {number} Value.
-       */
-      function(r) {
-        return Math.log(n / r) / e / s;
-      }
-    );
-  }
-  /**
-   * Returns the size of the viewport minus padding.
-   * @private
-   * @param {number} [rotation] Take into account the rotation of the viewport when giving the size
-   * @return {import("./size.js").Size} Viewport size reduced by the padding.
-   */
-  getViewportSizeMinusPadding_(t) {
-    let e = this.getViewportSize_(t);
-    const n = this.padding_;
-    return n && (e = [
-      e[0] - n[1] - n[3],
-      e[1] - n[0] - n[2]
-    ]), e;
-  }
-  /**
-   * @return {State} View state.
-   */
-  getState() {
-    const t = this.getProjection(), e = this.getResolution(), n = this.getRotation();
-    let i = (
-      /** @type {import("./coordinate.js").Coordinate} */
-      this.getCenterInternal()
-    );
-    const s = this.padding_;
-    if (s) {
-      const r = this.getViewportSizeMinusPadding_();
-      i = S(
-        i,
-        this.getViewportSize_(),
-        [r[0] / 2 + s[3], r[1] / 2 + s[0]],
-        e,
-        n
-      );
-    }
-    return {
-      center: i.slice(0),
-      projection: t !== void 0 ? t : null,
-      resolution: e,
-      nextCenter: this.nextCenter_,
-      nextResolution: this.nextResolution_,
-      nextRotation: this.nextRotation_,
-      rotation: n,
-      zoom: this.getZoom()
-    };
-  }
-  /**
-   * @return {ViewStateLayerStateExtent} Like `FrameState`, but just `viewState` and `extent`.
-   */
-  getViewStateAndExtent() {
-    return {
-      viewState: this.getState(),
-      extent: this.calculateExtent()
-    };
-  }
-  /**
-   * Get the current zoom level. This method may return non-integer zoom levels
-   * if the view does not constrain the resolution, or if an interaction or
-   * animation is underway.
-   * @return {number|undefined} Zoom.
-   * @api
-   */
-  getZoom() {
-    let t;
-    const e = this.getResolution();
-    return e !== void 0 && (t = this.getZoomForResolution(e)), t;
-  }
-  /**
-   * Get the zoom level for a resolution.
-   * @param {number} resolution The resolution.
-   * @return {number|undefined} The zoom level for the provided resolution.
-   * @api
-   */
-  getZoomForResolution(t) {
-    let e = this.minZoom_ || 0, n, i;
-    if (this.resolutions_) {
-      const s = U(this.resolutions_, t, 1);
-      e = s, n = this.resolutions_[s], s == this.resolutions_.length - 1 ? i = 2 : i = n / this.resolutions_[s + 1];
-    } else
-      n = this.maxResolution_, i = this.zoomFactor_;
-    return e + Math.log(n / t) / Math.log(i);
-  }
-  /**
-   * Get the resolution for a zoom level.
-   * @param {number} zoom Zoom level.
-   * @return {number} The view resolution for the provided zoom level.
-   * @api
-   */
-  getResolutionForZoom(t) {
-    var e;
-    if ((e = this.resolutions_) != null && e.length) {
-      if (this.resolutions_.length === 1)
-        return this.resolutions_[0];
-      const n = E(
-        Math.floor(t),
-        0,
-        this.resolutions_.length - 2
-      ), i = this.resolutions_[n] / this.resolutions_[n + 1];
-      return this.resolutions_[n] / Math.pow(i, E(t - n, 0, 1));
-    }
-    return this.maxResolution_ / Math.pow(this.zoomFactor_, t - this.minZoom_);
-  }
-  /**
-   * Fit the given geometry or extent based on the given map size and border.
-   * The size is pixel dimensions of the box to fit the extent into.
-   * In most cases you will want to use the map size, that is `map.getSize()`.
-   * Takes care of the map angle.
-   * @param {import("./geom/SimpleGeometry.js").default|import("./extent.js").Extent} geometryOrExtent The geometry or
-   *     extent to fit the view to.
-   * @param {FitOptions} [options] Options.
-   * @api
-   */
-  fit(t, e) {
-    let n;
-    if (I(
-      Array.isArray(t) || typeof /** @type {?} */
-      t.getSimplifiedGeometry == "function",
-      "Invalid extent or geometry provided as `geometry`"
-    ), Array.isArray(t)) {
-      I(
-        !K(t),
-        "Cannot fit empty extent provided as `geometry`"
-      );
-      const i = M(t, this.getProjection());
-      n = z(i);
-    } else if (t.getType() === "Circle") {
-      const i = M(
-        t.getExtent(),
-        this.getProjection()
-      );
-      n = z(i), n.rotate(this.getRotation(), T(i));
-    } else
-      n = t;
-    this.fitInternal(n, e);
-  }
-  /**
-   * Calculate rotated extent
-   * @param {import("./geom/SimpleGeometry.js").default} geometry The geometry.
-   * @return {import("./extent").Extent} The rotated extent for the geometry.
-   */
-  rotatedExtentForGeometry(t) {
-    const e = this.getRotation(), n = Math.cos(e), i = Math.sin(-e), s = t.getFlatCoordinates(), r = t.getStride();
-    let l = 1 / 0, o = 1 / 0, d = -1 / 0, u = -1 / 0;
-    for (let h = 0, c = s.length; h < c; h += r) {
-      const g = s[h] * n - s[h + 1] * i, f = s[h] * i + s[h + 1] * n;
-      l = Math.min(l, g), o = Math.min(o, f), d = Math.max(d, g), u = Math.max(u, f);
-    }
-    return [l, o, d, 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 i = e.padding !== void 0 ? e.padding : [0, 0, 0, 0], s = e.nearest !== void 0 ? e.nearest : !1;
-    let r;
-    e.minResolution !== void 0 ? r = e.minResolution : e.maxZoom !== void 0 ? r = this.getResolutionForZoom(e.maxZoom) : r = 0;
-    const l = this.rotatedExtentForGeometry(t);
-    let o = this.getResolutionForExtentInternal(l, [
-      n[0] - i[1] - i[3],
-      n[1] - i[0] - i[2]
-    ]);
-    o = isNaN(o) ? r : Math.max(o, r), o = this.getConstrainedResolution(o, s ? 0 : 1);
-    const d = this.getRotation(), u = Math.sin(d), h = Math.cos(d), c = T(l);
-    c[0] += (i[1] - i[3]) / 2 * o, c[1] += (i[0] - i[2]) / 2 * o;
-    const g = c[0] * h - c[1] * u, f = c[1] * h + c[0] * u, R = this.getConstrainedCenter([g, f], o), m = e.callback ? e.callback : W;
-    e.duration !== void 0 ? this.animateInternal(
-      {
-        resolution: o,
-        center: R,
-        duration: e.duration,
-        easing: e.easing
-      },
-      m
-    ) : (this.targetResolution_ = o, this.targetCenter_ = R, this.applyTargetState_(!1, !0), A(m, !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(
-      x(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(
-      S(
-        t,
-        e,
-        n,
-        this.getResolution(),
-        this.getRotation()
-      )
-    );
-  }
-  /**
-   * Calculates the shift between map and viewport center.
-   * @param {import("./coordinate.js").Coordinate} center Center.
-   * @param {number} resolution Resolution.
-   * @param {number} rotation Rotation.
-   * @param {import("./size.js").Size} size Size.
-   * @return {Array<number>|undefined} Center shift.
-   */
-  calculateCenterShift(t, e, n, i) {
-    let s;
-    const r = this.padding_;
-    if (r && t) {
-      const l = this.getViewportSizeMinusPadding_(-n), o = S(
-        t,
-        i,
-        [l[0] / 2 + r[3], l[1] / 2 + r[0]],
-        e,
-        n
-      );
-      s = [
-        t[0] - o[0],
-        t[1] - o[1]
-      ];
-    }
-    return s;
-  }
-  /**
-   * @return {boolean} Is defined.
-   */
-  isDef() {
-    return !!this.getCenterInternal() && this.getResolution() !== void 0;
-  }
-  /**
-   * Adds relative coordinates to the center of the view. Any extent constraint will apply.
-   * @param {import("./coordinate.js").Coordinate} deltaCoordinates Relative value to add.
-   * @api
-   */
-  adjustCenter(t) {
-    const e = N(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 && x(e, this.getProjection()), this.adjustResolutionInternal(t, e);
-  }
-  /**
-   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution
-   * constraint will apply.
-   * @param {number} ratio The ratio to apply on the view resolution.
-   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
-   */
-  adjustResolutionInternal(t, e) {
-    const n = this.getAnimating() || this.getInteracting(), i = this.getViewportSize_(this.getRotation()), s = this.constraints_.resolution(
-      this.targetResolution_ * t,
-      0,
-      i,
-      n
-    );
-    e && (this.targetCenter_ = this.calculateCenterZoom(s, e)), this.targetResolution_ *= t, this.applyTargetState_();
-  }
-  /**
-   * Adds a value to the view zoom level, optionally using an anchor. Any resolution
-   * constraint will apply.
-   * @param {number} delta Relative value to add to the zoom level.
-   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
-   * @api
-   */
-  adjustZoom(t, e) {
-    this.adjustResolution(Math.pow(this.zoomFactor_, -t), e);
-  }
-  /**
-   * Adds a value to the view rotation, optionally using an anchor. Any rotation
-   * constraint will apply.
-   * @param {number} delta Relative value to add to the zoom rotation, in radians.
-   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
-   * @api
-   */
-  adjustRotation(t, e) {
-    e && (e = x(e, this.getProjection())), this.adjustRotationInternal(t, e);
-  }
-  /**
-   * @param {number} delta Relative value to add to the zoom rotation, in radians.
-   * @param {import("./coordinate.js").Coordinate} [anchor] The rotation center.
-   */
-  adjustRotationInternal(t, e) {
-    const n = this.getAnimating() || this.getInteracting(), i = this.constraints_.rotation(
-      this.targetRotation_ + t,
-      n
-    );
-    e && (this.targetCenter_ = this.calculateCenterRotate(i, e)), this.targetRotation_ += t, this.applyTargetState_();
-  }
-  /**
-   * Set the center of the current view. Any extent constraint will apply.
-   * @param {import("./coordinate.js").Coordinate|undefined} center The center of the view.
-   * @observable
-   * @api
-   */
-  setCenter(t) {
-    this.setCenterInternal(
-      t && x(t, this.getProjection())
-    );
-  }
-  /**
-   * Set the center using the view projection (not the user projection).
-   * @param {import("./coordinate.js").Coordinate|undefined} center The center of the view.
-   */
-  setCenterInternal(t) {
-    this.targetCenter_ = t, this.applyTargetState_();
-  }
-  /**
-   * @param {import("./ViewHint.js").default} hint Hint.
-   * @param {number} delta Delta.
-   * @return {number} New value.
-   */
-  setHint(t, e) {
-    return this.hints_[t] += e, this.changed(), this.hints_[t];
-  }
-  /**
-   * Set the resolution for this view. Any resolution constraint will apply.
-   * @param {number|undefined} resolution The resolution of the view.
-   * @observable
-   * @api
-   */
-  setResolution(t) {
-    this.targetResolution_ = t, this.applyTargetState_();
-  }
-  /**
-   * Set the rotation for this view. Any rotation constraint will apply.
-   * @param {number} rotation The rotation of the view in radians.
-   * @observable
-   * @api
-   */
-  setRotation(t) {
-    this.targetRotation_ = t, this.applyTargetState_();
-  }
-  /**
-   * Zoom to a specific zoom level. Any resolution constrain will apply.
-   * @param {number} zoom Zoom level.
-   * @api
-   */
-  setZoom(t) {
-    this.setResolution(this.getResolutionForZoom(t));
-  }
-  /**
-   * Recompute rotation/resolution/center based on target values.
-   * Note: we have to compute rotation first, then resolution and center considering that
-   * parameters can influence one another in case a view extent constraint is present.
-   * @param {boolean} [doNotCancelAnims] Do not cancel animations.
-   * @param {boolean} [forceMoving] Apply constraints as if the view is moving.
-   * @private
-   */
-  applyTargetState_(t, e) {
-    const n = this.getAnimating() || this.getInteracting() || e, i = this.constraints_.rotation(
-      this.targetRotation_,
-      n
-    ), s = this.getViewportSize_(i), r = this.constraints_.resolution(
-      this.targetResolution_,
-      0,
-      s,
-      n
-    ), l = this.constraints_.center(
-      this.targetCenter_,
-      r,
-      s,
-      n,
-      this.calculateCenterShift(
-        this.targetCenter_,
-        r,
-        i,
-        s
-      )
-    );
-    this.get(_.ROTATION) !== i && this.set(_.ROTATION, i), this.get(_.RESOLUTION) !== r && (this.set(_.RESOLUTION, r), this.set("zoom", this.getZoom(), !0)), (!l || !this.get(_.CENTER) || !Z(this.get(_.CENTER), l)) && this.set(_.CENTER, l), this.getAnimating() && !t && this.cancelAnimations(), this.cancelAnchor_ = void 0;
-  }
-  /**
-   * If any constraints need to be applied, an animation will be triggered.
-   * This is typically done on interaction end.
-   * Note: calling this with a duration of 0 will apply the constrained values straight away,
-   * without animation.
-   * @param {number} [duration] The animation duration in ms.
-   * @param {number} [resolutionDirection] Which direction to zoom.
-   * @param {import("./coordinate.js").Coordinate} [anchor] The origin of the transformation.
-   */
-  resolveConstraints(t, e, n) {
-    t = t !== void 0 ? t : 200;
-    const i = e || 0, s = this.constraints_.rotation(this.targetRotation_), r = this.getViewportSize_(s), l = this.constraints_.resolution(
-      this.targetResolution_,
-      i,
-      r
-    ), o = this.constraints_.center(
-      this.targetCenter_,
-      l,
-      r,
-      !1,
-      this.calculateCenterShift(
-        this.targetCenter_,
-        l,
-        s,
-        r
-      )
-    );
-    if (t === 0 && !this.cancelAnchor_) {
-      this.targetResolution_ = l, this.targetRotation_ = s, this.targetCenter_ = o, this.applyTargetState_();
-      return;
-    }
-    n = n || (t === 0 ? this.cancelAnchor_ : void 0), this.cancelAnchor_ = void 0, (this.getResolution() !== l || this.getRotation() !== s || !this.getCenterInternal() || !Z(this.getCenterInternal(), o)) && (this.getAnimating() && this.cancelAnimations(), this.animateInternal({
-      rotation: s,
-      center: o,
-      resolution: l,
-      duration: t,
-      easing: X,
-      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(C.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 && x(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(C.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 A(a, t) {
-  setTimeout(function() {
-    a(t);
-  }, 0);
-}
-function st(a) {
-  if (a.extent !== void 0) {
-    const e = a.smoothExtentConstraint !== void 0 ? a.smoothExtentConstraint : !0;
-    return y(a.extent, a.constrainOnlyCenter, e);
-  }
-  const t = j(a.projection, "EPSG:3857");
-  if (a.multiWorld !== !0 && t.isGlobal()) {
-    const e = t.getExtent().slice();
-    return e[0] = -1 / 0, e[2] = 1 / 0, y(e, !1, !1);
-  }
-  return k;
-}
-function rt(a) {
-  let t, e, n, r = a.minZoom !== void 0 ? a.minZoom : w, l = a.maxZoom !== void 0 ? a.maxZoom : 28;
-  const o = a.zoomFactor !== void 0 ? a.zoomFactor : 2, d = a.multiWorld !== void 0 ? a.multiWorld : !1, u = a.smoothResolutionConstraint !== void 0 ? a.smoothResolutionConstraint : !0, h = a.showFullExtent !== void 0 ? a.showFullExtent : !1, c = j(a.projection, "EPSG:3857"), g = c.getExtent();
-  let f = a.constrainOnlyCenter, R = a.extent;
-  if (!d && !R && c.isGlobal() && (f = !1, R = g), a.resolutions !== void 0) {
-    const m = a.resolutions;
-    e = m[r], n = m[l] !== void 0 ? m[l] : m[m.length - 1], a.constrainResolution ? t = $(
-      m,
-      u,
-      !f && R,
-      h
-    ) : t = P(
-      e,
-      n,
-      u,
-      !f && R,
-      h
-    );
-  } else {
-    const p = (g ? Math.max(O(g), V(g)) : (
-      // use an extent that can fit the whole world if need be
-      360 * it.degrees / c.getMetersPerUnit()
-    )) / nt / Math.pow(2, w), v = p / Math.pow(2, 28 - w);
-    e = a.maxResolution, e !== void 0 ? r = 0 : e = p / Math.pow(o, r), n = a.minResolution, n === void 0 && (a.maxZoom !== void 0 ? a.maxResolution !== void 0 ? n = e / Math.pow(o, l) : n = p / Math.pow(o, l) : n = v), l = r + Math.floor(
-      Math.log(e / n) / Math.log(o)
-    ), n = e / Math.pow(o, l - r), a.constrainResolution ? t = J(
-      o,
-      e,
-      n,
-      u,
-      !f && R,
-      h
-    ) : t = P(
-      e,
-      n,
-      u,
-      !f && R,
-      h
-    );
-  }
-  return {
-    constraint: t,
-    maxResolution: e,
-    minResolution: n,
-    minZoom: r,
-    zoomFactor: o
-  };
-}
-function at(a) {
-  if (a.enableRotation !== void 0 ? a.enableRotation : !0) {
-    const e = a.constrainRotation;
-    return e === void 0 || e === !0 ? Q() : e === !1 ? b : typeof e == "number" ? tt(e) : b;
-  }
-  return et;
-}
-function lt(a) {
-  return !(a.sourceCenter && a.targetCenter && !Z(a.sourceCenter, a.targetCenter) || a.sourceResolution !== a.targetResolution || a.sourceRotation !== a.targetRotation);
-}
-function S(a, t, e, n, i) {
-  const s = Math.cos(-i);
-  let r = Math.sin(-i), l = a[0] * s - a[1] * r, o = a[1] * s + a[0] * r;
-  l += (t[0] / 2 - e[0]) * n, o += (e[1] - t[1] / 2) * n, r = -r;
-  const d = l * s - o * r, u = o * s + l * r;
-  return [d, u];
-}
-const Zt = ot;
-export {
-  st as createCenterConstraint,
-  rt as createResolutionConstraint,
-  at as createRotationConstraint,
-  Zt as default,
-  lt as isNoopAnimation
-};