@datagouv/components-next 0.2.0 → 1.0.0

package/dist/TileImage-CmZf8EdU.js

@@ -0,0 +1,1067 @@
+import { b as Y, e as f, d as G, h as I, w as D, I as v, R as K } from "./tilecoord-YW3qEH_j.js";
+import { t as g, s as k, T as _ } from "./Image-BN-4XkIn.js";
+import { aQ as N, an as W, p as b, L as q, a6 as B, N as x, R, C as S, M as H, D as $, K as y, W as V, aR as Q, U as J, B as tt, a as E, ak as et, I as it, e as z, E as nt } from "./proj-CKwYjU38.js";
+import { a as m, w as A, x as rt, D as st } from "./common-C4rDcQpp.js";
+const T = [0, 0, 0], d = 5;
+class p {
+  /**
+   * @param {Options} options Tile grid options.
+   */
+  constructor(t) {
+    this.minZoom = t.minZoom !== void 0 ? t.minZoom : 0, this.resolutions_ = t.resolutions, m(
+      N(
+        this.resolutions_,
+        /**
+         * @param {number} a First resolution
+         * @param {number} b Second resolution
+         * @return {number} Comparison result
+         */
+        (n, r) => r - n
+      ),
+      "`resolutions` must be sorted in descending order"
+    );
+    let e;
+    if (!t.origins) {
+      for (let n = 0, r = this.resolutions_.length - 1; n < r; ++n)
+        if (!e)
+          e = this.resolutions_[n] / this.resolutions_[n + 1];
+        else if (this.resolutions_[n] / this.resolutions_[n + 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, m(
+      this.origins_.length == this.resolutions_.length,
+      "Number of `origins` and `resolutions` must be equal"
+    ));
+    const i = t.extent;
+    i !== void 0 && !this.origin_ && !this.origins_ && (this.origin_ = W(i)), m(
+      !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, m(
+      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 : A, m(
+      !this.tileSize_ && this.tileSizes_ || this.tileSize_ && !this.tileSizes_,
+      "Either `tileSize` or `tileSizes` must be configured, never both"
+    ), this.extent_ = i !== void 0 ? i : null, this.fullTileRanges_ = null, this.tmpSize_ = [0, 0], this.tmpExtent_ = [0, 0, 0, 0], t.sizes !== void 0 ? this.fullTileRanges_ = t.sizes.map((n, r) => {
+      const s = new Y(
+        Math.min(0, n[0]),
+        Math.max(n[0] - 1, -1),
+        Math.min(0, n[1]),
+        Math.max(n[1] - 1, -1)
+      );
+      if (i) {
+        const l = this.getTileRangeForExtentAndZ(i, r);
+        s.minX = Math.max(l.minX, s.minX), s.maxX = Math.min(l.maxX, s.maxX), s.minY = Math.max(l.minY, s.minY), s.maxY = Math.min(l.maxY, s.maxY);
+      }
+      return s;
+    }) : i && this.calculateTileRanges_(i);
+  }
+  /**
+   * 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, i) {
+    const n = this.getTileRangeForExtentAndZ(t, e);
+    for (let r = n.minX, s = n.maxX; r <= s; ++r)
+      for (let l = n.minY, a = n.maxY; l <= a; ++l)
+        i([e, r, l]);
+  }
+  /**
+   * @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, i, n) {
+    let r, s, l, a = null, h = t[0] - 1;
+    for (this.zoomFactor_ === 2 ? (s = t[1], l = t[2]) : a = this.getTileCoordExtent(t, n); h >= this.minZoom; ) {
+      if (s !== void 0 && l !== void 0 ? (s = Math.floor(s / 2), l = Math.floor(l / 2), r = f(s, s, l, l, i)) : r = this.getTileRangeForExtentAndZ(
+        a,
+        h,
+        i
+      ), 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, i) {
+    if (t[0] < this.maxZoom) {
+      if (this.zoomFactor_ === 2) {
+        const r = t[1] * 2, s = t[2] * 2;
+        return f(
+          r,
+          r + 1,
+          s,
+          s + 1,
+          e
+        );
+      }
+      const n = this.getTileCoordExtent(
+        t,
+        i || this.tmpExtent_
+      );
+      return this.getTileRangeForExtentAndZ(
+        n,
+        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, i) {
+    if (e > this.maxZoom || e < this.minZoom)
+      return null;
+    const n = t[0], r = t[1], s = t[2];
+    if (e === n)
+      return f(
+        r,
+        s,
+        r,
+        s,
+        i
+      );
+    if (this.zoomFactor_) {
+      const a = Math.pow(this.zoomFactor_, e - n), h = Math.floor(r * a), u = Math.floor(s * a);
+      if (e < n)
+        return f(h, h, u, u, i);
+      const c = Math.floor(a * (r + 1)) - 1, F = Math.floor(a * (s + 1)) - 1;
+      return f(h, c, u, F, i);
+    }
+    const l = this.getTileCoordExtent(t, this.tmpExtent_);
+    return this.getTileRangeForExtentAndZ(l, e, i);
+  }
+  /**
+   * 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, i) {
+    this.getTileCoordForXYAndZ_(t[0], t[3], e, !1, T);
+    const n = T[1], r = T[2];
+    this.getTileCoordForXYAndZ_(t[2], t[1], e, !0, T);
+    const s = T[1], l = T[2];
+    return f(n, s, r, l, i);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {import("../coordinate.js").Coordinate} Tile center.
+   */
+  getTileCoordCenter(t) {
+    const e = this.getOrigin(t[0]), i = this.getResolution(t[0]), n = g(this.getTileSize(t[0]), this.tmpSize_);
+    return [
+      e[0] + (t[1] + 0.5) * n[0] * i,
+      e[1] - (t[2] + 0.5) * n[1] * i
+    ];
+  }
+  /**
+   * 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 i = this.getOrigin(t[0]), n = this.getResolution(t[0]), r = g(this.getTileSize(t[0]), this.tmpSize_), s = i[0] + t[1] * r[0] * n, l = i[1] - (t[2] + 1) * r[1] * n, a = s + r[0] * n, h = l + r[1] * n;
+    return b(s, l, a, 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, i) {
+    return this.getTileCoordForXYAndResolution_(
+      t[0],
+      t[1],
+      e,
+      !1,
+      i
+    );
+  }
+  /**
+   * 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, i, n, r) {
+    const s = this.getZForResolution(i), l = i / this.getResolution(s), a = this.getOrigin(s), h = g(this.getTileSize(s), this.tmpSize_);
+    let u = l * (t - a[0]) / i / h[0], c = l * (a[1] - e) / i / h[1];
+    return n ? (u = x(u, d) - 1, c = x(c, d) - 1) : (u = R(u, d), c = R(c, d)), G(s, 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, i, n, r) {
+    const s = this.getOrigin(i), l = this.getResolution(i), a = g(this.getTileSize(i), this.tmpSize_);
+    let h = (t - s[0]) / l / a[0], u = (s[1] - e) / l / a[1];
+    return n ? (h = x(h, d) - 1, u = x(u, d) - 1) : (h = R(h, d), u = R(u, d)), G(i, 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, i) {
+    return this.getTileCoordForXYAndZ_(
+      t[0],
+      t[1],
+      e,
+      !1,
+      i
+    );
+  }
+  /**
+   * @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 i = q(
+      this.resolutions_,
+      t,
+      e || 0
+    );
+    return B(i, 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 rt(
+      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, i = new Array(e);
+    for (let n = this.minZoom; n < e; ++n)
+      i[n] = this.getTileRangeForExtentAndZ(t, n);
+    this.fullTileRanges_ = i;
+  }
+}
+function w(o) {
+  let t = o.getDefaultTileGrid();
+  return t || (t = at(o), o.setDefaultTileGrid(t)), t;
+}
+function ot(o, t, e) {
+  const i = t[0], n = o.getTileCoordCenter(t), r = X(e);
+  if (!V(r, n)) {
+    const s = y(r), l = Math.ceil(
+      (r[0] - n[0]) / s
+    );
+    return n[0] += s * l, o.getTileCoordForCoordAndZ(n, i);
+  }
+  return t;
+}
+function lt(o, t, e, i) {
+  i = i !== void 0 ? i : "top-left";
+  const n = U(o, t, e);
+  return new p({
+    extent: o,
+    origin: Q(o, i),
+    resolutions: n,
+    tileSize: e
+  });
+}
+function Gt(o) {
+  const t = o || {}, e = t.extent || S("EPSG:3857").getExtent(), i = {
+    extent: e,
+    minZoom: t.minZoom,
+    tileSize: t.tileSize,
+    resolutions: U(
+      e,
+      t.maxZoom,
+      t.tileSize,
+      t.maxResolution
+    )
+  };
+  return new p(i);
+}
+function U(o, t, e, i) {
+  t = t !== void 0 ? t : st, e = g(e !== void 0 ? e : A);
+  const n = $(o), r = y(o);
+  i = i > 0 ? i : Math.max(r / e[0], n / e[1]);
+  const s = t + 1, l = new Array(s);
+  for (let a = 0; a < s; ++a)
+    l[a] = i / Math.pow(2, a);
+  return l;
+}
+function at(o, t, e, i) {
+  const n = X(o);
+  return lt(n, t, e, i);
+}
+function X(o) {
+  o = S(o);
+  let t = o.getExtent();
+  if (!t) {
+    const e = 180 * H.degrees / o.getMetersPerUnit();
+    t = b(-e, -e, e, e);
+  }
+  return t;
+}
+function jt(o, t) {
+  const e = [];
+  Object.keys(t).forEach(function(n) {
+    t[n] !== null && t[n] !== void 0 && e.push(n + "=" + encodeURIComponent(t[n]));
+  });
+  const i = e.join("&");
+  return o = o.replace(/[?&]$/, ""), o += o.includes("?") ? "&" : "?", o + i;
+}
+const ht = /\{z\}/g, ut = /\{x\}/g, ct = /\{y\}/g, dt = /\{-y\}/g;
+function gt(o, t, e, i, n) {
+  return o.replace(ht, t.toString()).replace(ut, e.toString()).replace(ct, i.toString()).replace(dt, function() {
+    if (n === void 0)
+      throw new Error(
+        "If the URL template has a {-y} placeholder, the grid extent must be known"
+      );
+    return (n - i).toString();
+  });
+}
+function ft(o) {
+  const t = [];
+  let e = /\{([a-z])-([a-z])\}/.exec(o);
+  if (e) {
+    const i = e[1].charCodeAt(0), n = e[2].charCodeAt(0);
+    let r;
+    for (r = i; r <= n; ++r)
+      t.push(o.replace(e[0], String.fromCharCode(r)));
+    return t;
+  }
+  if (e = /\{(\d+)-(\d+)\}/.exec(o), e) {
+    const i = parseInt(e[2], 10);
+    for (let n = parseInt(e[1], 10); n <= i; n++)
+      t.push(o.replace(e[0], n.toString()));
+    return t;
+  }
+  return t.push(o), t;
+}
+function Tt(o, t) {
+  return (
+    /**
+     * @param {import("./tilecoord.js").TileCoord} tileCoord Tile Coordinate.
+     * @param {number} pixelRatio Pixel ratio.
+     * @param {import("./proj/Projection.js").default} projection Projection.
+     * @return {string|undefined} Tile URL.
+     */
+    (function(e, i, n) {
+      if (!e)
+        return;
+      let r;
+      const s = e[0];
+      if (t) {
+        const l = t.getFullTileRange(s);
+        l && (r = l.getHeight() - 1);
+      }
+      return gt(o, s, e[1], e[2], r);
+    })
+  );
+}
+function mt(o, t) {
+  const e = o.length, i = new Array(e);
+  for (let n = 0; n < e; ++n)
+    i[n] = Tt(o[n], t);
+  return _t(i);
+}
+function _t(o) {
+  return o.length === 1 ? o[0] : (
+    /**
+     * @param {import("./tilecoord.js").TileCoord} tileCoord Tile Coordinate.
+     * @param {number} pixelRatio Pixel ratio.
+     * @param {import("./proj/Projection.js").default} projection Projection.
+     * @return {string|undefined} Tile URL.
+     */
+    (function(t, e, i) {
+      if (!t)
+        return;
+      const n = I(t), r = J(n, o.length);
+      return o[r](t, e, i);
+    })
+  );
+}
+class Ft extends tt {
+  /**
+   * @param {Options} options Source options.
+   */
+  constructor(t) {
+    super(), this.projection = S(t.projection), this.attributions_ = j(t.attributions), this.attributionsCollapsible_ = t.attributionsCollapsible ?? !0, this.loading = !1, this.state_ = t.state !== void 0 ? t.state : "ready", this.wrapX_ = t.wrapX !== void 0 ? t.wrapX : !1, this.interpolate_ = !!t.interpolate, this.viewResolver = null, this.viewRejector = null;
+    const e = this;
+    this.viewPromise_ = new Promise(function(i, n) {
+      e.viewResolver = i, e.viewRejector = n;
+    });
+  }
+  /**
+   * Get the attribution function for the source.
+   * @return {?Attribution} Attribution function.
+   * @api
+   */
+  getAttributions() {
+    return this.attributions_;
+  }
+  /**
+   * @return {boolean} Attributions are collapsible.
+   * @api
+   */
+  getAttributionsCollapsible() {
+    return this.attributionsCollapsible_;
+  }
+  /**
+   * Get the projection of the source.
+   * @return {import("../proj/Projection.js").default|null} Projection.
+   * @api
+   */
+  getProjection() {
+    return this.projection;
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   */
+  getResolutions(t) {
+    return null;
+  }
+  /**
+   * @return {Promise<import("../View.js").ViewOptions>} A promise for view-related properties.
+   */
+  getView() {
+    return this.viewPromise_;
+  }
+  /**
+   * Get the state of the source, see {@link import("./Source.js").State} for possible states.
+   * @return {import("./Source.js").State} State.
+   * @api
+   */
+  getState() {
+    return this.state_;
+  }
+  /**
+   * @return {boolean|undefined} Wrap X.
+   */
+  getWrapX() {
+    return this.wrapX_;
+  }
+  /**
+   * @return {boolean} Use linear interpolation when resampling.
+   */
+  getInterpolate() {
+    return this.interpolate_;
+  }
+  /**
+   * Refreshes the source. The source will be cleared, and data from the server will be reloaded.
+   * @api
+   */
+  refresh() {
+    this.changed();
+  }
+  /**
+   * Set the attributions of the source.
+   * @param {AttributionLike|undefined} attributions Attributions.
+   *     Can be passed as `string`, `Array<string>`, {@link module:ol/source/Source~Attribution},
+   *     or `undefined`.
+   * @api
+   */
+  setAttributions(t) {
+    this.attributions_ = j(t), this.changed();
+  }
+  /**
+   * Set the state of the source.
+   * @param {import("./Source.js").State} state State.
+   */
+  setState(t) {
+    this.state_ = t, this.changed();
+  }
+}
+function j(o) {
+  return o ? typeof o == "function" ? o : (Array.isArray(o) || (o = [o]), (t) => o) : null;
+}
+class xt extends Ft {
+  /**
+   * @param {Options} options SourceTile source options.
+   */
+  constructor(t) {
+    super({
+      attributions: t.attributions,
+      attributionsCollapsible: t.attributionsCollapsible,
+      projection: t.projection,
+      state: t.state,
+      wrapX: t.wrapX,
+      interpolate: t.interpolate
+    }), this.on, this.once, this.un, this.tilePixelRatio_ = t.tilePixelRatio !== void 0 ? t.tilePixelRatio : 1, this.tileGrid = t.tileGrid !== void 0 ? t.tileGrid : null;
+    const e = [256, 256];
+    this.tileGrid && g(this.tileGrid.getTileSize(this.tileGrid.getMinZoom()), e), this.tmpSize = [0, 0], this.key_ = t.key || E(this), this.tileOptions = {
+      transition: t.transition,
+      interpolate: t.interpolate
+    }, this.zDirection = t.zDirection ? t.zDirection : 0;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   */
+  getGutterForProjection(t) {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   */
+  getKey() {
+    return this.key_;
+  }
+  /**
+   * Set the value to be used as the key for all tiles in the source.
+   * @param {string} key The key for tiles.
+   * @protected
+   */
+  setKey(t) {
+    this.key_ !== t && (this.key_ = t, this.changed());
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   * @override
+   */
+  getResolutions(t) {
+    const e = t ? this.getTileGridForProjection(t) : this.tileGrid;
+    return e ? e.getResolutions() : null;
+  }
+  /**
+   * @abstract
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {TileType|null} Tile.
+   */
+  getTile(t, e, i, n, r) {
+    return et();
+  }
+  /**
+   * Return the tile grid of the tile source.
+   * @return {import("../tilegrid/TileGrid.js").default|null} Tile grid.
+   * @api
+   */
+  getTileGrid() {
+    return this.tileGrid;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   */
+  getTileGridForProjection(t) {
+    return this.tileGrid ? this.tileGrid : w(t);
+  }
+  /**
+   * Get the tile pixel ratio for this source. Subclasses may override this
+   * method, which is meant to return a supported pixel ratio that matches the
+   * provided `pixelRatio` as close as possible.
+   * @param {number} pixelRatio Pixel ratio.
+   * @return {number} Tile pixel ratio.
+   */
+  getTilePixelRatio(t) {
+    return this.tilePixelRatio_;
+  }
+  /**
+   * @param {number} z Z.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {import("../size.js").Size} Tile size.
+   */
+  getTilePixelSize(t, e, i) {
+    const n = this.getTileGridForProjection(i), r = this.getTilePixelRatio(e), s = g(n.getTileSize(t), this.tmpSize);
+    return r == 1 ? s : k(s, r, this.tmpSize);
+  }
+  /**
+   * Returns a tile coordinate wrapped around the x-axis. When the tile coordinate
+   * is outside the resolution and extent range of the tile grid, `null` will be
+   * returned.
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../proj/Projection.js").default} [projection] Projection.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate to be passed to the tileUrlFunction or
+   *     null if no tile URL should be created for the passed `tileCoord`.
+   */
+  getTileCoordForTileUrlFunction(t, e) {
+    const i = e !== void 0 ? e : this.getProjection(), n = e !== void 0 ? this.getTileGridForProjection(i) : this.tileGrid || this.getTileGridForProjection(i);
+    return this.getWrapX() && i.isGlobal() && (t = ot(n, t, i)), D(t, n) ? t : null;
+  }
+  /**
+   * Remove all cached reprojected tiles from the source. The next render cycle will create new tiles.
+   * @api
+   */
+  clear() {
+  }
+  /**
+   * @override
+   */
+  refresh() {
+    this.clear(), super.refresh();
+  }
+}
+class Rt extends it {
+  /**
+   * @param {string} type Type.
+   * @param {import("../Tile.js").default} tile The tile.
+   */
+  constructor(t, e) {
+    super(t), this.tile = e;
+  }
+}
+const P = {
+  /**
+   * Triggered when a tile starts loading.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadstart
+   * @api
+   */
+  TILELOADSTART: "tileloadstart",
+  /**
+   * Triggered when a tile finishes loading, either when its data is loaded,
+   * or when loading was aborted because the tile is no longer needed.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadend
+   * @api
+   */
+  TILELOADEND: "tileloadend",
+  /**
+   * Triggered if tile loading results in an error. Note that this is not the
+   * right place to re-fetch tiles. See {@link module:ol/ImageTile~ImageTile#load}
+   * for details.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloaderror
+   * @api
+   */
+  TILELOADERROR: "tileloaderror"
+};
+class C extends xt {
+  /**
+   * @param {Options} options Image tile options.
+   */
+  constructor(t) {
+    super({
+      attributions: t.attributions,
+      cacheSize: t.cacheSize,
+      projection: t.projection,
+      state: t.state,
+      tileGrid: t.tileGrid,
+      tilePixelRatio: t.tilePixelRatio,
+      wrapX: t.wrapX,
+      transition: t.transition,
+      interpolate: t.interpolate,
+      key: t.key,
+      attributionsCollapsible: t.attributionsCollapsible,
+      zDirection: t.zDirection
+    }), this.generateTileUrlFunction_ = this.tileUrlFunction === C.prototype.tileUrlFunction, this.tileLoadFunction = t.tileLoadFunction, t.tileUrlFunction && (this.tileUrlFunction = t.tileUrlFunction), this.urls = null, t.urls ? this.setUrls(t.urls) : t.url && this.setUrl(t.url), this.tileLoadingKeys_ = {};
+  }
+  /**
+   * Deprecated.  Use an ImageTile source instead.
+   * Return the tile load function of the source.
+   * @return {import("../Tile.js").LoadFunction} TileLoadFunction
+   * @api
+   */
+  getTileLoadFunction() {
+    return this.tileLoadFunction;
+  }
+  /**
+   * Deprecated.  Use an ImageTile source instead.
+   * Return the tile URL function of the source.
+   * @return {import("../Tile.js").UrlFunction} TileUrlFunction
+   * @api
+   */
+  getTileUrlFunction() {
+    return Object.getPrototypeOf(this).tileUrlFunction === this.tileUrlFunction ? this.tileUrlFunction.bind(this) : this.tileUrlFunction;
+  }
+  /**
+   * Deprecated.  Use an ImageTile source instead.
+   * Return the URLs used for this source.
+   * When a tileUrlFunction is used instead of url or urls,
+   * null will be returned.
+   * @return {!Array<string>|null} URLs.
+   * @api
+   */
+  getUrls() {
+    return this.urls;
+  }
+  /**
+   * Handle tile change events.
+   * @param {import("../events/Event.js").default} event Event.
+   * @protected
+   */
+  handleTileChange(t) {
+    const e = (
+      /** @type {import("../Tile.js").default} */
+      t.target
+    ), i = E(e), n = e.getState();
+    let r;
+    n == _.LOADING ? (this.tileLoadingKeys_[i] = !0, r = P.TILELOADSTART) : i in this.tileLoadingKeys_ && (delete this.tileLoadingKeys_[i], r = n == _.ERROR ? P.TILELOADERROR : n == _.LOADED ? P.TILELOADEND : void 0), r != null && this.dispatchEvent(new Rt(r, e));
+  }
+  /**
+   * Deprecated.  Use an ImageTile source instead.
+   * Set the tile load function of the source.
+   * @param {import("../Tile.js").LoadFunction} tileLoadFunction Tile load function.
+   * @api
+   */
+  setTileLoadFunction(t) {
+    this.tileLoadFunction = t, this.changed();
+  }
+  /**
+   * Deprecated.  Use an ImageTile source instead.
+   * Set the tile URL function of the source.
+   * @param {import("../Tile.js").UrlFunction} tileUrlFunction Tile URL function.
+   * @param {string} [key] Optional new tile key for the source.
+   * @api
+   */
+  setTileUrlFunction(t, e) {
+    this.tileUrlFunction = t, typeof e < "u" ? this.setKey(e) : this.changed();
+  }
+  /**
+   * Set the URL to use for requests.
+   * @param {string} url URL.
+   * @api
+   */
+  setUrl(t) {
+    const e = ft(t);
+    this.urls = e, this.setUrls(e);
+  }
+  /**
+   * Deprecated.  Use an ImageTile source instead.
+   * Set the URLs to use for requests.
+   * @param {Array<string>} urls URLs.
+   * @api
+   */
+  setUrls(t) {
+    this.urls = t;
+    const e = t.join(`
+`);
+    this.generateTileUrlFunction_ ? this.setTileUrlFunction(mt(t, this.tileGrid), e) : this.setKey(e);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {string|undefined} Tile URL.
+   */
+  tileUrlFunction(t, e, i) {
+  }
+}
+class bt extends C {
+  /**
+   * @param {!Options} options Image tile options.
+   */
+  constructor(t) {
+    super({
+      attributions: t.attributions,
+      cacheSize: t.cacheSize,
+      projection: t.projection,
+      state: t.state,
+      tileGrid: t.tileGrid,
+      tileLoadFunction: t.tileLoadFunction ? t.tileLoadFunction : Et,
+      tilePixelRatio: t.tilePixelRatio,
+      tileUrlFunction: t.tileUrlFunction,
+      url: t.url,
+      urls: t.urls,
+      wrapX: t.wrapX,
+      transition: t.transition,
+      interpolate: t.interpolate !== void 0 ? t.interpolate : !0,
+      key: t.key,
+      attributionsCollapsible: t.attributionsCollapsible,
+      zDirection: t.zDirection
+    }), this.crossOrigin = t.crossOrigin !== void 0 ? t.crossOrigin : null, this.tileClass = t.tileClass !== void 0 ? t.tileClass : v, this.tileGridForProjection = {}, this.reprojectionErrorThreshold_ = t.reprojectionErrorThreshold, this.renderReprojectionEdges_ = !1;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   * @override
+   */
+  getGutterForProjection(t) {
+    return this.getProjection() && t && !z(this.getProjection(), t) ? 0 : this.getGutter();
+  }
+  /**
+   * @return {number} Gutter.
+   */
+  getGutter() {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   * @override
+   */
+  getKey() {
+    let t = super.getKey();
+    return this.getInterpolate() || (t += ":disable-interpolation"), t;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   * @override
+   */
+  getTileGridForProjection(t) {
+    const e = this.getProjection();
+    if (this.tileGrid && (!e || z(e, t)))
+      return this.tileGrid;
+    const i = E(t);
+    return i in this.tileGridForProjection || (this.tileGridForProjection[i] = w(t)), this.tileGridForProjection[i];
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {string} key The key set on the tile.
+   * @return {!ImageTile} Tile.
+   * @private
+   */
+  createTile_(t, e, i, n, r, s) {
+    const l = [t, e, i], a = this.getTileCoordForTileUrlFunction(
+      l,
+      r
+    ), h = a ? this.tileUrlFunction(a, n, r) : void 0, u = new this.tileClass(
+      l,
+      h !== void 0 ? _.IDLE : _.EMPTY,
+      h !== void 0 ? h : "",
+      this.crossOrigin,
+      this.tileLoadFunction,
+      this.tileOptions
+    );
+    return u.key = s, u.addEventListener(nt.CHANGE, this.handleTileChange.bind(this)), u;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!(ImageTile|ReprojTile)} Tile.
+   * @override
+   */
+  getTile(t, e, i, n, r) {
+    const s = this.getProjection();
+    if (!s || !r || z(s, r))
+      return this.getTileInternal(
+        t,
+        e,
+        i,
+        n,
+        s || r
+      );
+    const l = [t, e, i], a = this.getKey(), h = this.getTileGridForProjection(s), u = this.getTileGridForProjection(r), c = this.getTileCoordForTileUrlFunction(
+      l,
+      r
+    ), F = new K(
+      s,
+      h,
+      r,
+      u,
+      l,
+      c,
+      this.getTilePixelRatio(n),
+      this.getGutter(),
+      (Z, O, L, M) => this.getTileInternal(Z, O, L, M, s),
+      this.reprojectionErrorThreshold_,
+      this.renderReprojectionEdges_,
+      this.tileOptions
+    );
+    return F.key = a, F;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {!import("../proj/Projection.js").default} projection Projection.
+   * @return {!ImageTile} Tile.
+   * @protected
+   */
+  getTileInternal(t, e, i, n, r) {
+    const s = this.getKey();
+    return this.createTile_(t, e, i, n, r, s);
+  }
+  /**
+   * Sets whether to render reprojection edges or not (usually for debugging).
+   * @param {boolean} render Render the edges.
+   * @api
+   */
+  setRenderReprojectionEdges(t) {
+    this.renderReprojectionEdges_ != t && (this.renderReprojectionEdges_ = t, this.changed());
+  }
+  /**
+   * Sets the tile grid to use when reprojecting the tiles to the given
+   * projection instead of the default tile grid for the projection.
+   *
+   * This can be useful when the default tile grid cannot be created
+   * (e.g. projection has no extent defined) or
+   * for optimization reasons (custom tile size, resolutions, ...).
+   *
+   * @param {import("../proj.js").ProjectionLike} projection Projection.
+   * @param {import("../tilegrid/TileGrid.js").default} tilegrid Tile grid to use for the projection.
+   * @api
+   */
+  setTileGridForProjection(t, e) {
+    const i = S(t);
+    if (i) {
+      const n = E(i);
+      n in this.tileGridForProjection || (this.tileGridForProjection[n] = e);
+    }
+  }
+}
+function Et(o, t) {
+  o.getImage().src = t;
+}
+export {
+  Ft as S,
+  bt as T,
+  C as U,
+  p as a,
+  jt as b,
+  Gt as c,
+  ft as d,
+  X as e,
+  _t as f,
+  mt as g
+};