@datagouv/components-next 0.2.0 → 1.0.1

package/dist/tilecoord-YW3qEH_j.js

@@ -0,0 +1,884 @@
+import { T as g, l as Et, c as N, b as et } from "./Image-BN-4XkIn.js";
+import { y as xt, g as Tt } from "./common-C4rDcQpp.js";
+import { aC as pt, E as lt, ak as It, S as ft, g as nt, W as Xt, v as Mt, D as K, m as dt, K as L, an as _t, aS as vt, w as Wt, q as Yt, aT as Lt, aj as yt, aI as Ft, az as wt, aJ as Dt, aU as st, ac as ot, i as Pt, U as z, a0 as J, d as V, l as Ct, u as at, a6 as rt, H as Ot } from "./proj-CKwYjU38.js";
+class gt extends pt {
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("./TileState.js").default} state State.
+   * @param {Options} [options] Tile options.
+   */
+  constructor(t, e, s) {
+    super(), s = s || {}, this.tileCoord = t, this.state = e, this.key = "", this.transition_ = s.transition === void 0 ? 250 : s.transition, this.transitionStarts_ = {}, this.interpolate = !!s.interpolate;
+  }
+  /**
+   * @protected
+   */
+  changed() {
+    this.dispatchEvent(lt.CHANGE);
+  }
+  /**
+   * Called by the tile cache when the tile is removed from the cache due to expiry
+   */
+  release() {
+    this.setState(g.EMPTY);
+  }
+  /**
+   * @return {string} Key.
+   */
+  getKey() {
+    return this.key + "/" + this.tileCoord;
+  }
+  /**
+   * Get the tile coordinate for this tile.
+   * @return {import("./tilecoord.js").TileCoord} The tile coordinate.
+   * @api
+   */
+  getTileCoord() {
+    return this.tileCoord;
+  }
+  /**
+   * @return {import("./TileState.js").default} State.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Sets the state of this tile. If you write your own {@link module:ol/Tile~LoadFunction tileLoadFunction} ,
+   * it is important to set the state correctly to {@link module:ol/TileState~ERROR}
+   * when the tile cannot be loaded. Otherwise the tile cannot be removed from
+   * the tile queue and will block other requests.
+   * @param {import("./TileState.js").default} state State.
+   * @api
+   */
+  setState(t) {
+    if (this.state !== g.EMPTY) {
+      if (this.state !== g.ERROR && this.state > t)
+        throw new Error("Tile load sequence violation");
+      this.state = t, this.changed();
+    }
+  }
+  /**
+   * Load the image or retry if loading previously failed.
+   * Loading is taken care of by the tile queue, and calling this method is
+   * only needed for preloading or for reloading in case of an error.
+   * @abstract
+   * @api
+   */
+  load() {
+    It();
+  }
+  /**
+   * Get the alpha value for rendering.
+   * @param {string} id An id for the renderer.
+   * @param {number} time The render frame time.
+   * @return {number} A number between 0 and 1.
+   */
+  getAlpha(t, e) {
+    if (!this.transition_)
+      return 1;
+    let s = this.transitionStarts_[t];
+    if (!s)
+      s = e, this.transitionStarts_[t] = s;
+    else if (s === -1)
+      return 1;
+    const n = e - s + 1e3 / 60;
+    return n >= this.transition_ ? 1 : xt(n / this.transition_);
+  }
+  /**
+   * Determine if a tile is in an alpha transition.  A tile is considered in
+   * transition if tile.getAlpha() has not yet been called or has been called
+   * and returned 1.
+   * @param {string} id An id for the renderer.
+   * @return {boolean} The tile is in transition.
+   */
+  inTransition(t) {
+    return this.transition_ ? this.transitionStarts_[t] !== -1 : !1;
+  }
+  /**
+   * Mark a transition as complete.
+   * @param {string} id An id for the renderer.
+   */
+  endTransition(t) {
+    this.transition_ && (this.transitionStarts_[t] = -1);
+  }
+  /**
+   * @override
+   */
+  disposeInternal() {
+    this.release(), super.disposeInternal();
+  }
+}
+class Qt extends gt {
+  /**
+   * @param {import("./tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("./TileState.js").default} state State.
+   * @param {string} src Image source URI.
+   * @param {?string} crossOrigin Cross origin.
+   * @param {import("./Tile.js").LoadFunction} tileLoadFunction Tile load function.
+   * @param {import("./Tile.js").Options} [options] Tile options.
+   */
+  constructor(t, e, s, n, i, c) {
+    super(t, e, c), this.crossOrigin_ = n, this.src_ = s, this.key = s, this.image_ = new Image(), n !== null && (this.image_.crossOrigin = n), this.unlisten_ = null, this.tileLoadFunction_ = i;
+  }
+  /**
+   * Get the HTML image element for this tile (may be a Canvas, Image, or Video).
+   * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
+   * @api
+   */
+  getImage() {
+    return this.image_;
+  }
+  /**
+   * Sets an HTML image element for this tile (may be a Canvas or preloaded Image).
+   * @param {HTMLCanvasElement|HTMLImageElement} element Element.
+   */
+  setImage(t) {
+    this.image_ = t, this.state = g.LOADED, this.unlistenImage_(), this.changed();
+  }
+  /**
+   * Tracks loading or read errors.
+   *
+   * @private
+   */
+  handleImageError_() {
+    this.state = g.ERROR, this.unlistenImage_(), this.image_ = At(), this.changed();
+  }
+  /**
+   * Tracks successful image load.
+   *
+   * @private
+   */
+  handleImageLoad_() {
+    const t = (
+      /** @type {HTMLImageElement} */
+      this.image_
+    );
+    t.naturalWidth && t.naturalHeight ? this.state = g.LOADED : this.state = g.EMPTY, this.unlistenImage_(), this.changed();
+  }
+  /**
+   * Load the image or retry if loading previously failed.
+   * Loading is taken care of by the tile queue, and calling this method is
+   * only needed for preloading or for reloading in case of an error.
+   *
+   * To retry loading tiles on failed requests, use a custom `tileLoadFunction`
+   * that checks for error status codes and reloads only when the status code is
+   * 408, 429, 500, 502, 503 and 504, and only when not too many retries have been
+   * made already:
+   *
+   * ```js
+   * const retryCodes = [408, 429, 500, 502, 503, 504];
+   * const retries = {};
+   * source.setTileLoadFunction((tile, src) => {
+   *   const image = tile.getImage();
+   *   fetch(src)
+   *     .then((response) => {
+   *       if (retryCodes.includes(response.status)) {
+   *         retries[src] = (retries[src] || 0) + 1;
+   *         if (retries[src] <= 3) {
+   *           setTimeout(() => tile.load(), retries[src] * 1000);
+   *         }
+   *         return Promise.reject();
+   *       }
+   *       return response.blob();
+   *     })
+   *     .then((blob) => {
+   *       const imageUrl = URL.createObjectURL(blob);
+   *       image.src = imageUrl;
+   *       setTimeout(() => URL.revokeObjectURL(imageUrl), 5000);
+   *     })
+   *     .catch(() => tile.setState(3)); // error
+   * });
+   * ```
+   * @api
+   * @override
+   */
+  load() {
+    this.state == g.ERROR && (this.state = g.IDLE, this.image_ = new Image(), this.crossOrigin_ !== null && (this.image_.crossOrigin = this.crossOrigin_)), this.state == g.IDLE && (this.state = g.LOADING, this.changed(), this.tileLoadFunction_(this, this.src_), this.unlisten_ = Et(
+      this.image_,
+      this.handleImageLoad_.bind(this),
+      this.handleImageError_.bind(this)
+    ));
+  }
+  /**
+   * Discards event handlers which listen for load completion or errors.
+   *
+   * @private
+   */
+  unlistenImage_() {
+    this.unlisten_ && (this.unlisten_(), this.unlisten_ = null);
+  }
+  /**
+   * @override
+   */
+  disposeInternal() {
+    this.unlistenImage_(), this.image_ = null, super.disposeInternal();
+  }
+}
+function At() {
+  const o = N(1, 1);
+  return o.fillStyle = "rgba(0,0,0,0)", o.fillRect(0, 0, 1, 1), o.canvas;
+}
+class Rt {
+  /**
+   * @param {number} minX Minimum X.
+   * @param {number} maxX Maximum X.
+   * @param {number} minY Minimum Y.
+   * @param {number} maxY Maximum Y.
+   */
+  constructor(t, e, s, n) {
+    this.minX = t, this.maxX = e, this.minY = s, this.maxY = n;
+  }
+  /**
+   * @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 jt(o, t, e, s, n) {
+  return n !== void 0 ? (n.minX = o, n.maxX = t, n.minY = e, n.maxY = s, n) : new Rt(o, t, e, s);
+}
+let $;
+const B = [];
+function ht(o, t, e, s, n) {
+  o.beginPath(), o.moveTo(0, 0), o.lineTo(t, e), o.lineTo(s, n), o.closePath(), o.save(), o.clip(), o.fillRect(0, 0, Math.max(t, s) + 1, Math.max(e, n)), o.restore();
+}
+function tt(o, t) {
+  return Math.abs(o[t * 4] - 210) > 2 || Math.abs(o[t * 4 + 3] - 0.75 * 255) > 2;
+}
+function kt() {
+  if ($ === void 0) {
+    const o = N(6, 6, B);
+    o.globalCompositeOperation = "lighter", o.fillStyle = "rgba(210, 0, 0, 0.75)", ht(o, 4, 5, 4, 0), ht(o, 4, 5, 0, 5);
+    const t = o.getImageData(0, 0, 3, 3).data;
+    $ = tt(t, 0) || tt(t, 4) || tt(t, 8), et(o), B.push(o.canvas);
+  }
+  return $;
+}
+function ct(o, t, e, s) {
+  const n = ft(e, t, o);
+  let i = nt(
+    t,
+    s,
+    e
+  );
+  const c = t.getMetersPerUnit();
+  c !== void 0 && (i *= c);
+  const m = o.getMetersPerUnit();
+  m !== void 0 && (i /= m);
+  const _ = o.getExtent();
+  if (!_ || Xt(_, n)) {
+    const T = nt(o, i, n) / i;
+    isFinite(T) && T > 0 && (i /= T);
+  }
+  return i;
+}
+function Bt(o, t, e, s) {
+  const n = Wt(e);
+  let i = ct(
+    o,
+    t,
+    n,
+    s
+  );
+  return (!isFinite(i) || i <= 0) && Yt(e, function(c) {
+    return i = ct(
+      o,
+      t,
+      c,
+      s
+    ), isFinite(i) && i > 0;
+  }), i;
+}
+function Gt(o, t, e, s, n, i, c, m, _, T, X, x, y, F) {
+  const r = N(
+    Math.round(e * o),
+    Math.round(e * t),
+    B
+  );
+  if (x || (r.imageSmoothingEnabled = !1), _.length === 0)
+    return r.canvas;
+  r.scale(e, e);
+  function h(a) {
+    return Math.round(a * e) / e;
+  }
+  r.globalCompositeOperation = "lighter";
+  const E = dt();
+  _.forEach(function(a, w, C) {
+    Mt(E, a.extent);
+  });
+  let l;
+  const f = e / s, d = (x ? 1 : 1 + Math.pow(2, -24)) / f;
+  (!y || _.length !== 1 || T !== 0) && (l = N(
+    Math.round(L(E) * f),
+    Math.round(K(E) * f),
+    B
+  ), x || (l.imageSmoothingEnabled = !1), _.forEach(function(a, w, C) {
+    if (a.image.width > 0 && a.image.height > 0) {
+      if (a.clipExtent) {
+        l.save();
+        const M = (a.clipExtent[0] - E[0]) * f, v = -(a.clipExtent[3] - E[3]) * f, D = L(a.clipExtent) * f, A = K(a.clipExtent) * f;
+        l.rect(
+          x ? M : Math.round(M),
+          x ? v : Math.round(v),
+          x ? D : Math.round(M + D) - Math.round(M),
+          x ? A : Math.round(v + A) - Math.round(v)
+        ), l.clip();
+      }
+      const p = (a.extent[0] - E[0]) * f, I = -(a.extent[3] - E[3]) * f, W = L(a.extent) * f, Y = K(a.extent) * f;
+      l.drawImage(
+        a.image,
+        T,
+        T,
+        a.image.width - 2 * T,
+        a.image.height - 2 * T,
+        x ? p : Math.round(p),
+        x ? I : Math.round(I),
+        x ? W : Math.round(p + W) - Math.round(p),
+        x ? Y : Math.round(I + Y) - Math.round(I)
+      ), a.clipExtent && l.restore();
+    }
+  }));
+  const u = _t(c);
+  return m.getTriangles().forEach(function(a, w, C) {
+    const p = a.source, I = a.target;
+    let W = p[0][0], Y = p[0][1], M = p[1][0], v = p[1][1], D = p[2][0], A = p[2][1];
+    const G = h((I[0][0] - u[0]) / i), Z = h(
+      -(I[0][1] - u[1]) / i
+    ), R = h((I[1][0] - u[0]) / i), k = h(
+      -(I[1][1] - u[1]) / i
+    ), U = h((I[2][0] - u[0]) / i), Q = h(
+      -(I[2][1] - u[1]) / i
+    ), j = W, q = Y;
+    W = 0, Y = 0, M -= j, v -= q, D -= j, A -= q;
+    const mt = [
+      [M, v, 0, 0, R - G],
+      [D, A, 0, 0, U - G],
+      [0, 0, M, v, k - Z],
+      [0, 0, D, A, Q - Z]
+    ], H = vt(mt);
+    if (!H)
+      return;
+    if (r.save(), r.beginPath(), kt() || !x) {
+      r.moveTo(R, k);
+      const P = 4, b = G - R, it = Z - k;
+      for (let O = 0; O < P; O++)
+        r.lineTo(
+          R + h((O + 1) * b / P),
+          k + h(O * it / (P - 1))
+        ), O != P - 1 && r.lineTo(
+          R + h((O + 1) * b / P),
+          k + h((O + 1) * it / (P - 1))
+        );
+      r.lineTo(U, Q);
+    } else
+      r.moveTo(R, k), r.lineTo(G, Z), r.lineTo(U, Q);
+    r.clip(), r.transform(
+      H[0],
+      H[2],
+      H[1],
+      H[3],
+      G,
+      Z
+    ), r.translate(
+      E[0] - j,
+      E[3] - q
+    );
+    let S;
+    if (l)
+      S = l.canvas, r.scale(d, -d);
+    else {
+      const P = _[0], b = P.extent;
+      S = P.image, r.scale(
+        L(b) / S.width,
+        -K(b) / S.height
+      );
+    }
+    r.drawImage(S, 0, 0), r.restore();
+  }), l && (et(l), B.push(l.canvas)), X && (r.save(), r.globalCompositeOperation = "source-over", r.strokeStyle = "black", r.lineWidth = 1, m.getTriangles().forEach(function(a, w, C) {
+    const p = a.target, I = (p[0][0] - u[0]) / i, W = -(p[0][1] - u[1]) / i, Y = (p[1][0] - u[0]) / i, M = -(p[1][1] - u[1]) / i, v = (p[2][0] - u[0]) / i, D = -(p[2][1] - u[1]) / i;
+    r.beginPath(), r.moveTo(Y, M), r.lineTo(I, W), r.lineTo(v, D), r.closePath(), r.stroke();
+  }), r.restore()), r.canvas;
+}
+const Zt = 10, ut = 0.25;
+class Ht {
+  /**
+   * @param {import("../proj/Projection.js").default} sourceProj Source projection.
+   * @param {import("../proj/Projection.js").default} targetProj Target projection.
+   * @param {import("../extent.js").Extent} targetExtent Target extent to triangulate.
+   * @param {import("../extent.js").Extent} maxSourceExtent Maximal source extent that can be used.
+   * @param {number} errorThreshold Acceptable error (in source units).
+   * @param {?number} destinationResolution The (optional) resolution of the destination.
+   * @param {import("../transform.js").Transform} [sourceMatrix] Source transform matrix.
+   */
+  constructor(t, e, s, n, i, c, m) {
+    this.sourceProj_ = t, this.targetProj_ = e;
+    let _ = {};
+    const T = m ? Lt(
+      (d) => Tt(
+        m,
+        ft(d, this.targetProj_, this.sourceProj_)
+      )
+    ) : yt(this.targetProj_, this.sourceProj_);
+    this.transformInv_ = function(d) {
+      const u = d[0] + "/" + d[1];
+      return _[u] || (_[u] = T(d)), _[u];
+    }, this.maxSourceExtent_ = n, this.errorThresholdSquared_ = i * i, this.triangles_ = [], this.wrapsXInSource_ = !1, this.canWrapXInSource_ = this.sourceProj_.canWrapX() && !!n && !!this.sourceProj_.getExtent() && L(n) >= L(this.sourceProj_.getExtent()), this.sourceWorldWidth_ = this.sourceProj_.getExtent() ? L(this.sourceProj_.getExtent()) : null, this.targetWorldWidth_ = this.targetProj_.getExtent() ? L(this.targetProj_.getExtent()) : null;
+    const X = _t(s), x = Ft(s), y = wt(s), F = Dt(s), r = this.transformInv_(X), h = this.transformInv_(x), E = this.transformInv_(y), l = this.transformInv_(F), f = Zt + (c ? Math.max(
+      0,
+      Math.ceil(
+        Math.log2(
+          st(s) / (c * c * 256 * 256)
+        )
+      )
+    ) : 0);
+    if (this.addQuad_(
+      X,
+      x,
+      y,
+      F,
+      r,
+      h,
+      E,
+      l,
+      f
+    ), this.wrapsXInSource_) {
+      let d = 1 / 0;
+      this.triangles_.forEach(function(u, a, w) {
+        d = Math.min(
+          d,
+          u.source[0][0],
+          u.source[1][0],
+          u.source[2][0]
+        );
+      }), this.triangles_.forEach((u) => {
+        if (Math.max(
+          u.source[0][0],
+          u.source[1][0],
+          u.source[2][0]
+        ) - d > this.sourceWorldWidth_ / 2) {
+          const a = [
+            [u.source[0][0], u.source[0][1]],
+            [u.source[1][0], u.source[1][1]],
+            [u.source[2][0], u.source[2][1]]
+          ];
+          a[0][0] - d > this.sourceWorldWidth_ / 2 && (a[0][0] -= this.sourceWorldWidth_), a[1][0] - d > this.sourceWorldWidth_ / 2 && (a[1][0] -= this.sourceWorldWidth_), a[2][0] - d > this.sourceWorldWidth_ / 2 && (a[2][0] -= this.sourceWorldWidth_);
+          const w = Math.min(
+            a[0][0],
+            a[1][0],
+            a[2][0]
+          );
+          Math.max(
+            a[0][0],
+            a[1][0],
+            a[2][0]
+          ) - w < this.sourceWorldWidth_ / 2 && (u.source = a);
+        }
+      });
+    }
+    _ = {};
+  }
+  /**
+   * Adds triangle to the triangulation.
+   * @param {import("../coordinate.js").Coordinate} a The target a coordinate.
+   * @param {import("../coordinate.js").Coordinate} b The target b coordinate.
+   * @param {import("../coordinate.js").Coordinate} c The target c coordinate.
+   * @param {import("../coordinate.js").Coordinate} aSrc The source a coordinate.
+   * @param {import("../coordinate.js").Coordinate} bSrc The source b coordinate.
+   * @param {import("../coordinate.js").Coordinate} cSrc The source c coordinate.
+   * @private
+   */
+  addTriangle_(t, e, s, n, i, c) {
+    this.triangles_.push({
+      source: [n, i, c],
+      target: [t, e, s]
+    });
+  }
+  /**
+   * Adds quad (points in clock-wise order) to the triangulation
+   * (and reprojects the vertices) if valid.
+   * Performs quad subdivision if needed to increase precision.
+   *
+   * @param {import("../coordinate.js").Coordinate} a The target a coordinate.
+   * @param {import("../coordinate.js").Coordinate} b The target b coordinate.
+   * @param {import("../coordinate.js").Coordinate} c The target c coordinate.
+   * @param {import("../coordinate.js").Coordinate} d The target d coordinate.
+   * @param {import("../coordinate.js").Coordinate} aSrc The source a coordinate.
+   * @param {import("../coordinate.js").Coordinate} bSrc The source b coordinate.
+   * @param {import("../coordinate.js").Coordinate} cSrc The source c coordinate.
+   * @param {import("../coordinate.js").Coordinate} dSrc The source d coordinate.
+   * @param {number} maxSubdivision Maximal allowed subdivision of the quad.
+   * @private
+   */
+  addQuad_(t, e, s, n, i, c, m, _, T) {
+    const X = ot([i, c, m, _]), x = this.sourceWorldWidth_ ? L(X) / this.sourceWorldWidth_ : null, y = (
+      /** @type {number} */
+      this.sourceWorldWidth_
+    ), F = this.sourceProj_.canWrapX() && x > 0.5 && x < 1;
+    let r = !1;
+    if (T > 0) {
+      if (this.targetProj_.isGlobal() && this.targetWorldWidth_) {
+        const E = ot([t, e, s, n]);
+        r = L(E) / this.targetWorldWidth_ > ut || r;
+      }
+      !F && this.sourceProj_.isGlobal() && x && (r = x > ut || r);
+    }
+    if (!r && this.maxSourceExtent_ && isFinite(X[0]) && isFinite(X[1]) && isFinite(X[2]) && isFinite(X[3]) && !Pt(X, this.maxSourceExtent_))
+      return;
+    let h = 0;
+    if (!r && (!isFinite(i[0]) || !isFinite(i[1]) || !isFinite(c[0]) || !isFinite(c[1]) || !isFinite(m[0]) || !isFinite(m[1]) || !isFinite(_[0]) || !isFinite(_[1]))) {
+      if (T > 0)
+        r = !0;
+      else if (h = (!isFinite(i[0]) || !isFinite(i[1]) ? 8 : 0) + (!isFinite(c[0]) || !isFinite(c[1]) ? 4 : 0) + (!isFinite(m[0]) || !isFinite(m[1]) ? 2 : 0) + (!isFinite(_[0]) || !isFinite(_[1]) ? 1 : 0), h != 1 && h != 2 && h != 4 && h != 8)
+        return;
+    }
+    if (T > 0) {
+      if (!r) {
+        const E = [(t[0] + s[0]) / 2, (t[1] + s[1]) / 2], l = this.transformInv_(E);
+        let f;
+        F ? f = (z(i[0], y) + z(m[0], y)) / 2 - z(l[0], y) : f = (i[0] + m[0]) / 2 - l[0];
+        const d = (i[1] + m[1]) / 2 - l[1];
+        r = f * f + d * d > this.errorThresholdSquared_;
+      }
+      if (r) {
+        if (Math.abs(t[0] - s[0]) <= Math.abs(t[1] - s[1])) {
+          const E = [(e[0] + s[0]) / 2, (e[1] + s[1]) / 2], l = this.transformInv_(E), f = [(n[0] + t[0]) / 2, (n[1] + t[1]) / 2], d = this.transformInv_(f);
+          this.addQuad_(
+            t,
+            e,
+            E,
+            f,
+            i,
+            c,
+            l,
+            d,
+            T - 1
+          ), this.addQuad_(
+            f,
+            E,
+            s,
+            n,
+            d,
+            l,
+            m,
+            _,
+            T - 1
+          );
+        } else {
+          const E = [(t[0] + e[0]) / 2, (t[1] + e[1]) / 2], l = this.transformInv_(E), f = [(s[0] + n[0]) / 2, (s[1] + n[1]) / 2], d = this.transformInv_(f);
+          this.addQuad_(
+            t,
+            E,
+            f,
+            n,
+            i,
+            l,
+            d,
+            _,
+            T - 1
+          ), this.addQuad_(
+            E,
+            e,
+            s,
+            f,
+            l,
+            c,
+            m,
+            d,
+            T - 1
+          );
+        }
+        return;
+      }
+    }
+    if (F) {
+      if (!this.canWrapXInSource_)
+        return;
+      this.wrapsXInSource_ = !0;
+    }
+    (h & 11) == 0 && this.addTriangle_(t, s, n, i, m, _), (h & 14) == 0 && this.addTriangle_(t, s, e, i, m, c), h && ((h & 13) == 0 && this.addTriangle_(e, n, t, c, _, i), (h & 7) == 0 && this.addTriangle_(e, n, s, c, _, m));
+  }
+  /**
+   * Calculates extent of the `source` coordinates from all the triangles.
+   *
+   * @return {import("../extent.js").Extent} Calculated extent.
+   */
+  calculateSourceExtent() {
+    const t = dt();
+    return this.triangles_.forEach(function(e, s, n) {
+      const i = e.source;
+      J(t, i[0]), J(t, i[1]), J(t, i[2]);
+    }), t;
+  }
+  /**
+   * @return {Array<Triangle>} Array of the calculated triangles.
+   */
+  getTriangles() {
+    return this.triangles_;
+  }
+}
+const St = 0.5;
+class qt extends gt {
+  /**
+   * @param {import("../proj/Projection.js").default} sourceProj Source projection.
+   * @param {import("../tilegrid/TileGrid.js").default} sourceTileGrid Source tile grid.
+   * @param {import("../proj/Projection.js").default} targetProj Target projection.
+   * @param {import("../tilegrid/TileGrid.js").default} targetTileGrid Target tile grid.
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Coordinate of the tile.
+   * @param {import("../tilecoord.js").TileCoord} wrappedTileCoord Coordinate of the tile wrapped in X.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {number} gutter Gutter of the source tiles.
+   * @param {FunctionType} getTileFunction
+   *     Function returning source tiles (z, x, y, pixelRatio).
+   * @param {number} [errorThreshold] Acceptable reprojection error (in px).
+   * @param {boolean} [renderEdges] Render reprojection edges.
+   * @param {import("../Tile.js").Options} [options] Tile options.
+   */
+  constructor(t, e, s, n, i, c, m, _, T, X, x, y) {
+    super(i, g.IDLE, y), this.renderEdges_ = x !== void 0 ? x : !1, this.pixelRatio_ = m, this.gutter_ = _, this.canvas_ = null, this.sourceTileGrid_ = e, this.targetTileGrid_ = n, this.wrappedTileCoord_ = c || i, this.sourceTiles_ = [], this.sourcesListenerKeys_ = null, this.sourceZ_ = 0, this.clipExtent_ = t.canWrapX() ? t.getExtent() : void 0;
+    const F = n.getTileCoordExtent(
+      this.wrappedTileCoord_
+    ), r = this.targetTileGrid_.getExtent();
+    let h = this.sourceTileGrid_.getExtent();
+    const E = r ? V(F, r) : F;
+    if (st(E) === 0) {
+      this.state = g.EMPTY;
+      return;
+    }
+    const l = t.getExtent();
+    l && (h ? h = V(h, l) : h = l);
+    const f = n.getResolution(
+      this.wrappedTileCoord_[0]
+    ), d = Bt(
+      t,
+      s,
+      E,
+      f
+    );
+    if (!isFinite(d) || d <= 0) {
+      this.state = g.EMPTY;
+      return;
+    }
+    const u = X !== void 0 ? X : St;
+    if (this.triangulation_ = new Ht(
+      t,
+      s,
+      E,
+      h,
+      d * u,
+      f
+    ), this.triangulation_.getTriangles().length === 0) {
+      this.state = g.EMPTY;
+      return;
+    }
+    this.sourceZ_ = e.getZForResolution(d);
+    let a = this.triangulation_.calculateSourceExtent();
+    if (h && (t.canWrapX() ? (a[1] = rt(
+      a[1],
+      h[1],
+      h[3]
+    ), a[3] = rt(
+      a[3],
+      h[1],
+      h[3]
+    )) : a = V(a, h)), !st(a))
+      this.state = g.EMPTY;
+    else {
+      let w = 0, C = 0;
+      t.canWrapX() && (w = L(l), C = Math.floor(
+        (a[0] - l[0]) / w
+      )), Ot(
+        a.slice(),
+        t,
+        !0
+      ).forEach((I) => {
+        const W = e.getTileRangeForExtentAndZ(
+          I,
+          this.sourceZ_
+        );
+        for (let Y = W.minX; Y <= W.maxX; Y++)
+          for (let M = W.minY; M <= W.maxY; M++) {
+            const v = T(this.sourceZ_, Y, M, m);
+            if (v) {
+              const D = C * w;
+              this.sourceTiles_.push({ tile: v, offset: D });
+            }
+          }
+        ++C;
+      }), this.sourceTiles_.length === 0 && (this.state = g.EMPTY);
+    }
+  }
+  /**
+   * Get the HTML Canvas element for this tile.
+   * @return {HTMLCanvasElement} Canvas.
+   */
+  getImage() {
+    return this.canvas_;
+  }
+  /**
+   * @private
+   */
+  reproject_() {
+    const t = [];
+    if (this.sourceTiles_.forEach((e) => {
+      const s = e.tile;
+      if (s && s.getState() == g.LOADED) {
+        const n = this.sourceTileGrid_.getTileCoordExtent(s.tileCoord);
+        n[0] += e.offset, n[2] += e.offset;
+        const i = this.clipExtent_?.slice();
+        i && (i[0] += e.offset, i[2] += e.offset), t.push({
+          extent: n,
+          clipExtent: i,
+          image: s.getImage()
+        });
+      }
+    }), this.sourceTiles_.length = 0, t.length === 0)
+      this.state = g.ERROR;
+    else {
+      const e = this.wrappedTileCoord_[0], s = this.targetTileGrid_.getTileSize(e), n = typeof s == "number" ? s : s[0], i = typeof s == "number" ? s : s[1], c = this.targetTileGrid_.getResolution(e), m = this.sourceTileGrid_.getResolution(
+        this.sourceZ_
+      ), _ = this.targetTileGrid_.getTileCoordExtent(
+        this.wrappedTileCoord_
+      );
+      this.canvas_ = Gt(
+        n,
+        i,
+        this.pixelRatio_,
+        m,
+        this.sourceTileGrid_.getExtent(),
+        c,
+        _,
+        this.triangulation_,
+        t,
+        this.gutter_,
+        this.renderEdges_,
+        this.interpolate
+      ), this.state = g.LOADED;
+    }
+    this.changed();
+  }
+  /**
+   * Load not yet loaded URI.
+   * @override
+   */
+  load() {
+    if (this.state == g.IDLE) {
+      this.state = g.LOADING, this.changed();
+      let t = 0;
+      this.sourcesListenerKeys_ = [], this.sourceTiles_.forEach(({ tile: e }) => {
+        const s = e.getState();
+        if (s == g.IDLE || s == g.LOADING) {
+          t++;
+          const n = Ct(e, lt.CHANGE, (i) => {
+            const c = e.getState();
+            (c == g.LOADED || c == g.ERROR || c == g.EMPTY) && (at(n), t--, t === 0 && (this.unlistenSources_(), this.reproject_()));
+          });
+          this.sourcesListenerKeys_.push(n);
+        }
+      }), t === 0 ? setTimeout(this.reproject_.bind(this), 0) : this.sourceTiles_.forEach(function({ tile: e }, s, n) {
+        e.getState() == g.IDLE && e.load();
+      });
+    }
+  }
+  /**
+   * @private
+   */
+  unlistenSources_() {
+    this.sourcesListenerKeys_.forEach(at), this.sourcesListenerKeys_ = null;
+  }
+  /**
+   * Remove from the cache due to expiry
+   * @override
+   */
+  release() {
+    this.canvas_ && (et(this.canvas_.getContext("2d")), B.push(this.canvas_), this.canvas_ = null), super.release();
+  }
+}
+function zt(o, t, e, s) {
+  return s !== void 0 ? (s[0] = o, s[1] = t, s[2] = e, s) : [o, t, e];
+}
+function Jt(o, t, e) {
+  return o + "/" + t + "/" + e;
+}
+function Vt(o) {
+  return bt(o[0], o[1], o[2]);
+}
+function bt(o, t, e) {
+  return (t << o) + e;
+}
+function $t(o, t) {
+  const e = o[0], s = o[1], n = o[2];
+  if (t.getMinZoom() > e || e > t.getMaxZoom())
+    return !1;
+  const i = t.getFullTileRange(e);
+  return i ? i.containsXY(s, n) : !0;
+}
+export {
+  St as E,
+  Qt as I,
+  qt as R,
+  gt as T,
+  Ht as a,
+  Rt as b,
+  ct as c,
+  zt as d,
+  jt as e,
+  Jt as g,
+  Vt as h,
+  Gt as r,
+  $t as w
+};