@datagouv/components-next 0.2.0 → 1.0.0

package/dist/Tile-DCuqwNOI.js

@@ -0,0 +1,1206 @@
+import { T as De, b as Oe, d as ye, I as Ke, R as Pe, g as Me } from "./tilecoord-YW3qEH_j.js";
+import { T, g as Te, d as j, c as Ee, t as ze } from "./Image-BN-4XkIn.js";
+import { aF as be, aH as Ae, ak as ee, E as ke, _ as je, an as Ce, aI as Fe, az as Ze, aJ as Ne, K as Ue, D as Ge, m as Be, W as qe, a as z, aK as He, j as re, d as oe, a1 as Ve, i as We, G as Xe } from "./proj-CKwYjU38.js";
+import { a as te, e as ne, o as Ye, g as v, d as ae, n as $e, p as Qe } from "./common-C4rDcQpp.js";
+import { a as xe, R as Je, E as X, L as et } from "./Event-BOgJUhNR.js";
+function le(d) {
+  return d instanceof Image || d instanceof HTMLCanvasElement || d instanceof HTMLVideoElement || d instanceof ImageBitmap ? d : null;
+}
+const tt = new Error("disposed"), nt = [256, 256];
+class Re extends De {
+  /**
+   * @param {Options} options Tile options.
+   */
+  constructor(e) {
+    const t = T.IDLE;
+    super(e.tileCoord, t, {
+      transition: e.transition,
+      interpolate: e.interpolate
+    }), this.loader_ = e.loader, this.data_ = null, this.error_ = null, this.size_ = e.size || null, this.controller_ = e.controller || null;
+  }
+  /**
+   * Get the tile size.
+   * @return {import('./size.js').Size} Tile size.
+   */
+  getSize() {
+    if (this.size_)
+      return this.size_;
+    const e = le(this.data_);
+    return e ? [e.width, e.height] : nt;
+  }
+  /**
+   * Get the data for the tile.
+   * @return {Data} Tile data.
+   * @api
+   */
+  getData() {
+    return this.data_;
+  }
+  /**
+   * Get any loading error.
+   * @return {Error} Loading error.
+   * @api
+   */
+  getError() {
+    return this.error_;
+  }
+  /**
+   * Load the tile data.
+   * @api
+   * @override
+   */
+  load() {
+    if (this.state !== T.IDLE && this.state !== T.ERROR)
+      return;
+    this.state = T.LOADING, this.changed();
+    const e = this;
+    this.loader_().then(function(t) {
+      e.data_ = t, e.state = T.LOADED, e.changed();
+    }).catch(function(t) {
+      e.error_ = t, e.state = T.ERROR, e.changed();
+    });
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.controller_ && (this.controller_.abort(tt), this.controller_ = null), super.disposeInternal();
+  }
+}
+class it {
+  /**
+   * @param {number} [highWaterMark] High water mark.
+   */
+  constructor(e) {
+    this.highWaterMark = e !== void 0 ? e : 2048, this.count_ = 0, this.entries_ = {}, this.oldest_ = null, this.newest_ = null;
+  }
+  deleteOldest() {
+    const e = this.pop();
+    e instanceof be && e.dispose();
+  }
+  /**
+   * @return {boolean} Can expire cache.
+   */
+  canExpireCache() {
+    return this.highWaterMark > 0 && this.getCount() > this.highWaterMark;
+  }
+  /**
+   * Expire the cache. When the cache entry is a {@link module:ol/Disposable~Disposable},
+   * the entry will be disposed.
+   * @param {!Object<string, boolean>} [keep] Keys to keep. To be implemented by subclasses.
+   */
+  expireCache(e) {
+    for (; this.canExpireCache(); )
+      this.deleteOldest();
+  }
+  /**
+   * FIXME empty description for jsdoc
+   */
+  clear() {
+    for (; this.oldest_; )
+      this.deleteOldest();
+  }
+  /**
+   * @param {string} key Key.
+   * @return {boolean} Contains key.
+   */
+  containsKey(e) {
+    return this.entries_.hasOwnProperty(e);
+  }
+  /**
+   * @param {function(T, string, LRUCache<T>): ?} f The function
+   *     to call for every entry from the oldest to the newer. This function takes
+   *     3 arguments (the entry value, the entry key and the LRUCache object).
+   *     The return value is ignored.
+   */
+  forEach(e) {
+    let t = this.oldest_;
+    for (; t; )
+      e(t.value_, t.key_, this), t = t.newer;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {*} [options] Options (reserved for subclasses).
+   * @return {T} Value.
+   */
+  get(e, t) {
+    const n = this.entries_[e];
+    return te(
+      n !== void 0,
+      "Tried to get a value for a key that does not exist in the cache"
+    ), n === this.newest_ || (n === this.oldest_ ? (this.oldest_ = /** @type {Entry} */
+    this.oldest_.newer, this.oldest_.older = null) : (n.newer.older = n.older, n.older.newer = n.newer), n.newer = null, n.older = this.newest_, this.newest_.newer = n, this.newest_ = n), n.value_;
+  }
+  /**
+   * Remove an entry from the cache.
+   * @param {string} key The entry key.
+   * @return {T} The removed entry.
+   */
+  remove(e) {
+    const t = this.entries_[e];
+    return te(
+      t !== void 0,
+      "Tried to get a value for a key that does not exist in the cache"
+    ), t === this.newest_ ? (this.newest_ = /** @type {Entry} */
+    t.older, this.newest_ && (this.newest_.newer = null)) : t === this.oldest_ ? (this.oldest_ = /** @type {Entry} */
+    t.newer, this.oldest_ && (this.oldest_.older = null)) : (t.newer.older = t.older, t.older.newer = t.newer), delete this.entries_[e], --this.count_, t.value_;
+  }
+  /**
+   * @return {number} Count.
+   */
+  getCount() {
+    return this.count_;
+  }
+  /**
+   * @return {Array<string>} Keys.
+   */
+  getKeys() {
+    const e = new Array(this.count_);
+    let t = 0, n;
+    for (n = this.newest_; n; n = n.older)
+      e[t++] = n.key_;
+    return e;
+  }
+  /**
+   * @return {Array<T>} Values.
+   */
+  getValues() {
+    const e = new Array(this.count_);
+    let t = 0, n;
+    for (n = this.newest_; n; n = n.older)
+      e[t++] = n.value_;
+    return e;
+  }
+  /**
+   * @return {T} Last value.
+   */
+  peekLast() {
+    return this.oldest_.value_;
+  }
+  /**
+   * @return {string} Last key.
+   */
+  peekLastKey() {
+    return this.oldest_.key_;
+  }
+  /**
+   * Get the key of the newest item in the cache.  Throws if the cache is empty.
+   * @return {string} The newest key.
+   */
+  peekFirstKey() {
+    return this.newest_.key_;
+  }
+  /**
+   * Return an entry without updating least recently used time.
+   * @param {string} key Key.
+   * @return {T|undefined} Value.
+   */
+  peek(e) {
+    return this.entries_[e]?.value_;
+  }
+  /**
+   * @return {T} value Value.
+   */
+  pop() {
+    const e = this.oldest_;
+    return delete this.entries_[e.key_], e.newer && (e.newer.older = null), this.oldest_ = /** @type {Entry} */
+    e.newer, this.oldest_ || (this.newest_ = null), --this.count_, e.value_;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {T} value Value.
+   */
+  replace(e, t) {
+    this.get(e), this.entries_[e].value_ = t;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {T} value Value.
+   */
+  set(e, t) {
+    te(
+      !(e in this.entries_),
+      "Tried to set a value for a key that is used already"
+    );
+    const n = {
+      key_: e,
+      newer: null,
+      older: this.newest_,
+      value_: t
+    };
+    this.newest_ ? this.newest_.newer = n : this.oldest_ = n, this.newest_ = n, this.entries_[e] = n, ++this.count_;
+  }
+  /**
+   * Set a maximum number of entries for the cache.
+   * @param {number} size Cache size.
+   * @api
+   */
+  setSize(e) {
+    this.highWaterMark = e;
+  }
+}
+class st {
+  constructor() {
+    this.instructions_ = [], this.zIndex = 0, this.offset_ = 0, this.context_ = /** @type {ZIndexContextProxy} */
+    new Proxy(Te(), {
+      get: (e, t) => {
+        if (typeof /** @type {*} */
+        Te()[t] == "function")
+          return this.push_(t), this.pushMethodArgs_;
+      },
+      set: (e, t, n) => (this.push_(t, n), !0)
+    });
+  }
+  /**
+   * @param {...*} args Arguments to push to the instructions array.
+   * @private
+   */
+  push_(...e) {
+    const t = this.instructions_, n = this.zIndex + this.offset_;
+    t[n] || (t[n] = []), t[n].push(...e);
+  }
+  /**
+   * @private
+   * @param {...*} args Args.
+   * @return {ZIndexContext} This.
+   */
+  pushMethodArgs_ = (...e) => (this.push_(e), this);
+  /**
+   * Push a function that renders to the context directly.
+   * @param {function(CanvasRenderingContext2D): void} render Function.
+   */
+  pushFunction(e) {
+    this.push_(e);
+  }
+  /**
+   * Get a proxy for CanvasRenderingContext2D which does not support getting state
+   * (e.g. `context.globalAlpha`, which will return `undefined`). To set state, if it relies on a
+   * previous state (e.g. `context.globalAlpha = context.globalAlpha / 2`), set a function,
+   * e.g. `context.globalAlpha = (context) => context.globalAlpha / 2`.
+   * @return {ZIndexContextProxy} Context.
+   */
+  getContext() {
+    return this.context_;
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   */
+  draw(e) {
+    this.instructions_.forEach((t) => {
+      for (let n = 0, i = t.length; n < i; ++n) {
+        const r = t[n];
+        if (typeof r == "function") {
+          r(e);
+          continue;
+        }
+        const a = t[++n];
+        if (typeof /** @type {*} */
+        e[r] == "function")
+          e[r](...a);
+        else {
+          if (typeof a == "function") {
+            e[r] = a(e);
+            continue;
+          }
+          e[r] = a;
+        }
+      }
+    });
+  }
+  clear() {
+    this.instructions_.length = 0, this.zIndex = 0, this.offset_ = 0;
+  }
+  /**
+   * Offsets the zIndex by the highest current zIndex. Useful for rendering multiple worlds or tiles, to
+   * avoid conflicting context.clip() or context.save()/restore() calls.
+   */
+  offset() {
+    this.offset_ = this.instructions_.length, this.zIndex = 0;
+  }
+}
+const rt = 5;
+class ot extends Ae {
+  /**
+   * @param {LayerType} layer Layer.
+   */
+  constructor(e) {
+    super(), this.ready = !0, this.boundHandleImageChange_ = this.handleImageChange_.bind(this), this.layer_ = e, this.staleKeys_ = new Array(), this.maxStaleKeys = rt;
+  }
+  /**
+   * @return {Array<string>} Get the list of stale keys.
+   */
+  getStaleKeys() {
+    return this.staleKeys_;
+  }
+  /**
+   * @param {string} key The new stale key.
+   */
+  prependStaleKey(e) {
+    this.staleKeys_.unshift(e), this.staleKeys_.length > this.maxStaleKeys && (this.staleKeys_.length = this.maxStaleKeys);
+  }
+  /**
+   * Asynchronous layer level hit detection.
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with
+   * an array of features.
+   */
+  getFeatures(e) {
+    return ee();
+  }
+  /**
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   */
+  getData(e) {
+    return null;
+  }
+  /**
+   * Determine whether render should be called.
+   * @abstract
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   */
+  prepareFrame(e) {
+    return ee();
+  }
+  /**
+   * Render the layer.
+   * @abstract
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement|null} target Target that may be used to render content to.
+   * @return {HTMLElement} The rendered element.
+   */
+  renderFrame(e, t) {
+    return ee();
+  }
+  /**
+   * @abstract
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
+   * @param {Array<import("./Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  forEachFeatureAtCoordinate(e, t, n, i, r) {
+  }
+  /**
+   * @return {LayerType} Layer.
+   */
+  getLayer() {
+    return this.layer_;
+  }
+  /**
+   * Perform action necessary to get the layer rendered after new fonts have loaded
+   * @abstract
+   */
+  handleFontsChanged() {
+  }
+  /**
+   * Handle changes in image state.
+   * @param {import("../events/Event.js").default} event Image change event.
+   * @private
+   */
+  handleImageChange_(e) {
+    const t = (
+      /** @type {import("../Image.js").default} */
+      e.target
+    );
+    (t.getState() === j.LOADED || t.getState() === j.ERROR) && this.renderIfReadyAndVisible();
+  }
+  /**
+   * Load the image if not already loaded, and register the image change
+   * listener if needed.
+   * @param {import("../Image.js").default} image Image.
+   * @return {boolean} `true` if the image is already loaded, `false` otherwise.
+   * @protected
+   */
+  loadImage(e) {
+    let t = e.getState();
+    return t != j.LOADED && t != j.ERROR && e.addEventListener(ke.CHANGE, this.boundHandleImageChange_), t == j.IDLE && (e.load(), t = e.getState()), t == j.LOADED;
+  }
+  /**
+   * @protected
+   */
+  renderIfReadyAndVisible() {
+    const e = this.getLayer();
+    e && e.getVisible() && e.getSourceState() === "ready" && e.changed();
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeferred(e) {
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    delete this.layer_, super.disposeInternal();
+  }
+}
+const Tt = [];
+let F = null;
+function at() {
+  F = Ee(1, 1, void 0, {
+    willReadFrequently: !0
+  });
+}
+class lt extends ot {
+  /**
+   * @param {LayerType} layer Layer.
+   */
+  constructor(e) {
+    super(e), this.container = null, this.renderedResolution, this.tempTransform = ne(), this.pixelTransform = ne(), this.inversePixelTransform = ne(), this.context = null, this.deferredContext_ = null, this.containerReused = !1, this.frameState = null;
+  }
+  /**
+   * @param {import('../../DataTile.js').ImageLike} image Image.
+   * @param {number} col The column index.
+   * @param {number} row The row index.
+   * @return {Uint8ClampedArray|null} The image data.
+   */
+  getImageData(e, t, n) {
+    F || at(), F.clearRect(0, 0, 1, 1);
+    let i;
+    try {
+      F.drawImage(e, t, n, 1, 1, 0, 0, 1, 1), i = F.getImageData(0, 0, 1, 1).data;
+    } catch {
+      return F = null, null;
+    }
+    return i;
+  }
+  /**
+   * @param {import('../../Map.js').FrameState} frameState Frame state.
+   * @return {string} Background color.
+   */
+  getBackground(e) {
+    let n = this.getLayer().getBackground();
+    return typeof n == "function" && (n = n(e.viewState.resolution)), n || void 0;
+  }
+  /**
+   * Get a rendering container from an existing target, if compatible.
+   * @param {HTMLElement} target Potential render target.
+   * @param {string} transform CSS transform matrix.
+   * @param {string} [backgroundColor] Background color.
+   */
+  useContainer(e, t, n) {
+    const i = this.getLayer().getClassName();
+    let r, a;
+    if (e && e.className === i && (!n || e && e.style.backgroundColor && je(
+      xe(e.style.backgroundColor),
+      xe(n)
+    ))) {
+      const s = e.firstElementChild;
+      s instanceof HTMLCanvasElement && (a = s.getContext("2d"));
+    }
+    if (a && Ye(a.canvas.style.transform, t) ? (this.container = e, this.context = a, this.containerReused = !0) : this.containerReused ? (this.container = null, this.context = null, this.containerReused = !1) : this.container && (this.container.style.backgroundColor = null), !this.container) {
+      r = document.createElement("div"), r.className = i;
+      let s = r.style;
+      s.position = "absolute", s.width = "100%", s.height = "100%", a = Ee();
+      const l = a.canvas;
+      r.appendChild(l), s = l.style, s.position = "absolute", s.left = "0", s.transformOrigin = "top left", this.container = r, this.context = a;
+    }
+    !this.containerReused && n && !this.container.style.backgroundColor && (this.container.style.backgroundColor = n);
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {import("../../extent.js").Extent} extent Clip extent.
+   * @protected
+   */
+  clipUnrotated(e, t, n) {
+    const i = Ce(n), r = Fe(n), a = Ze(n), s = Ne(n);
+    v(t.coordinateToPixelTransform, i), v(t.coordinateToPixelTransform, r), v(t.coordinateToPixelTransform, a), v(t.coordinateToPixelTransform, s);
+    const l = this.inversePixelTransform;
+    v(l, i), v(l, r), v(l, a), v(l, s), e.save(), e.beginPath(), e.moveTo(Math.round(i[0]), Math.round(i[1])), e.lineTo(Math.round(r[0]), Math.round(r[1])), e.lineTo(Math.round(a[0]), Math.round(a[1])), e.lineTo(Math.round(s[0]), Math.round(s[1])), e.clip();
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target that may be used to render content to.
+   * @protected
+   */
+  prepareContainer(e, t) {
+    const n = e.extent, i = e.viewState.resolution, r = e.viewState.rotation, a = e.pixelRatio, s = Math.round(Ue(n) / i * a), l = Math.round(Ge(n) / i * a);
+    ae(
+      this.pixelTransform,
+      e.size[0] / 2,
+      e.size[1] / 2,
+      1 / a,
+      1 / a,
+      r,
+      -s / 2,
+      -l / 2
+    ), $e(this.inversePixelTransform, this.pixelTransform);
+    const c = Qe(this.pixelTransform);
+    if (this.useContainer(t, c, this.getBackground(e)), !this.containerReused) {
+      const o = this.context.canvas;
+      o.width != s || o.height != l ? (o.width = s, o.height = l) : this.context.clearRect(0, 0, s, l), c !== o.style.transform && (o.style.transform = c);
+    }
+  }
+  /**
+   * @param {import("../../render/EventType.js").default} type Event type.
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @private
+   */
+  dispatchRenderEvent_(e, t, n) {
+    const i = this.getLayer();
+    if (i.hasListener(e)) {
+      const r = new Je(
+        e,
+        this.inversePixelTransform,
+        n,
+        t
+      );
+      i.dispatchEvent(r);
+    }
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  preRender(e, t) {
+    this.frameState = t, !t.declutter && this.dispatchRenderEvent_(X.PRERENDER, e, t);
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  postRender(e, t) {
+    t.declutter || this.dispatchRenderEvent_(X.POSTRENDER, e, t);
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeferredInternal(e) {
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {import('../../render/canvas/ZIndexContext.js').ZIndexContextProxy} Context.
+   */
+  getRenderContext(e) {
+    return e.declutter && !this.deferredContext_ && (this.deferredContext_ = new st()), e.declutter ? this.deferredContext_.getContext() : this.context;
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @override
+   */
+  renderDeferred(e) {
+    e.declutter && (this.dispatchRenderEvent_(
+      X.PRERENDER,
+      this.context,
+      e
+    ), e.declutter && this.deferredContext_ && (this.deferredContext_.draw(this.context), this.deferredContext_.clear()), this.renderDeferredInternal(e), this.dispatchRenderEvent_(
+      X.POSTRENDER,
+      this.context,
+      e
+    ));
+  }
+  /**
+   * Creates a transform for rendering to an element that will be rotated after rendering.
+   * @param {import("../../coordinate.js").Coordinate} center Center.
+   * @param {number} resolution Resolution.
+   * @param {number} rotation Rotation.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {number} width Width of the rendered element (in pixels).
+   * @param {number} height Height of the rendered element (in pixels).
+   * @param {number} offsetX Offset on the x-axis in view coordinates.
+   * @protected
+   * @return {!import("../../transform.js").Transform} Transform.
+   */
+  getRenderTransform(e, t, n, i, r, a, s) {
+    const l = r / 2, c = a / 2, o = i / t, u = -o, h = -e[0] + s, g = -e[1];
+    return ae(
+      this.tempTransform,
+      l,
+      c,
+      o,
+      u,
+      -n,
+      h,
+      g
+    );
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    delete this.frameState, super.disposeInternal();
+  }
+}
+function ie(d, e, t, n, i) {
+  return `${z(d)},${e},${Me(t, n, i)}`;
+}
+function se(d, e, t) {
+  if (!(t in d))
+    return d[t] = /* @__PURE__ */ new Set([e]), !0;
+  const n = d[t], i = n.has(e);
+  return i || n.add(e), !i;
+}
+function ct(d, e, t) {
+  const n = d[t];
+  return n ? n.delete(e) : !1;
+}
+function me(d, e) {
+  const t = d.layerStatesArray[d.layerIndex];
+  t.extent && (e = oe(
+    e,
+    re(t.extent, d.viewState.projection)
+  ));
+  const n = (
+    /** @type {import("../../source/Tile.js").default} */
+    t.layer.getRenderSource()
+  );
+  if (!n.getWrapX()) {
+    const i = n.getTileGridForProjection(d.viewState.projection).getExtent();
+    i && (e = oe(e, i));
+  }
+  return e;
+}
+class ht extends lt {
+  /**
+   * @param {LayerType} tileLayer Tile layer.
+   * @param {Options} [options] Options.
+   */
+  constructor(e, t) {
+    super(e), t = t || {}, this.extentChanged = !0, this.renderComplete = !1, this.renderedExtent_ = null, this.renderedPixelRatio, this.renderedProjection = null, this.renderedTiles = [], this.renderedSourceKey_, this.renderedSourceRevision_, this.tempExtent = Be(), this.tempTileRange_ = new Oe(0, 0, 0, 0), this.tempTileCoord_ = ye(0, 0, 0);
+    const n = t.cacheSize !== void 0 ? t.cacheSize : 512;
+    this.tileCache_ = new it(n), this.maxStaleKeys = n * 0.5;
+  }
+  /**
+   * @return {LRUCache} Tile cache.
+   */
+  getTileCache() {
+    return this.tileCache_;
+  }
+  /**
+   * Get a tile from the cache or create one if needed.
+   *
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {import("../../Tile.js").default|null} Tile (or null if outside source extent).
+   * @protected
+   */
+  getOrCreateTile(e, t, n, i) {
+    const r = this.tileCache_, s = this.getLayer().getSource(), l = ie(s, s.getKey(), e, t, n);
+    let c;
+    if (r.containsKey(l))
+      c = r.get(l);
+    else {
+      if (c = s.getTile(
+        e,
+        t,
+        n,
+        i.pixelRatio,
+        i.viewState.projection
+      ), !c)
+        return null;
+      r.set(l, c);
+    }
+    return c;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {import("../../Tile.js").default|null} Tile (or null if outside source extent).
+   * @protected
+   */
+  getTile(e, t, n, i) {
+    const r = this.getOrCreateTile(e, t, n, i);
+    return r || null;
+  }
+  /**
+   * @param {import("../../pixel.js").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray} Data at the pixel location.
+   * @override
+   */
+  getData(e) {
+    const t = this.frameState;
+    if (!t)
+      return null;
+    const n = this.getLayer(), i = v(
+      t.pixelToCoordinateTransform,
+      e.slice()
+    ), r = n.getExtent();
+    if (r && !qe(r, i))
+      return null;
+    const a = t.viewState, s = n.getRenderSource(), l = s.getTileGridForProjection(a.projection), c = s.getTilePixelRatio(t.pixelRatio);
+    for (let o = l.getZForResolution(a.resolution); o >= l.getMinZoom(); --o) {
+      const u = l.getTileCoordForCoordAndZ(i, o), h = this.getTile(o, u[1], u[2], t);
+      if (!h || h.getState() !== T.LOADED)
+        continue;
+      const g = l.getOrigin(o), p = ze(l.getTileSize(o)), S = l.getResolution(o);
+      let f;
+      if (h instanceof Ke || h instanceof Pe)
+        f = h.getImage();
+      else if (h instanceof Re) {
+        if (f = le(h.getData()), !f)
+          continue;
+      } else
+        continue;
+      const C = Math.floor(
+        c * ((i[0] - g[0]) / S - u[1] * p[0])
+      ), P = Math.floor(
+        c * ((g[1] - i[1]) / S - u[2] * p[1])
+      ), E = Math.round(
+        c * s.getGutterForProjection(a.projection)
+      );
+      return this.getImageData(f, C + E, P + E);
+    }
+    return null;
+  }
+  /**
+   * Determine whether render should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   * @override
+   */
+  prepareFrame(e) {
+    this.renderedProjection ? e.viewState.projection !== this.renderedProjection && (this.tileCache_.clear(), this.renderedProjection = e.viewState.projection) : this.renderedProjection = e.viewState.projection;
+    const t = this.getLayer().getSource();
+    if (!t)
+      return !1;
+    const n = t.getRevision();
+    return this.renderedSourceRevision_ ? this.renderedSourceRevision_ !== n && (this.renderedSourceRevision_ = n, this.renderedSourceKey_ === t.getKey() && this.tileCache_.clear()) : this.renderedSourceRevision_ = n, !0;
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {import("../../extent.js").Extent} extent The extent to be rendered.
+   * @param {number} initialZ The zoom level.
+   * @param {TileLookup} tilesByZ Lookup of tiles by zoom level.
+   * @param {number} preload Number of additional levels to load.
+   */
+  enqueueTiles(e, t, n, i, r) {
+    const a = e.viewState, s = this.getLayer(), l = s.getRenderSource(), c = l.getTileGridForProjection(a.projection), o = z(l);
+    o in e.wantedTiles || (e.wantedTiles[o] = {});
+    const u = e.wantedTiles[o], h = s.getMapInternal(), g = Math.max(
+      n - r,
+      c.getMinZoom(),
+      c.getZForResolution(
+        Math.min(
+          s.getMaxResolution(),
+          h ? h.getView().getResolutionForZoom(Math.max(s.getMinZoom(), 0)) : c.getResolution(0)
+        ),
+        l.zDirection
+      )
+    ), p = a.rotation, S = p ? He(
+      a.center,
+      a.resolution,
+      p,
+      e.size
+    ) : void 0;
+    for (let f = n; f >= g; --f) {
+      const C = c.getTileRangeForExtentAndZ(
+        t,
+        f,
+        this.tempTileRange_
+      ), P = c.getResolution(f);
+      for (let E = C.minX; E <= C.maxX; ++E)
+        for (let I = C.minY; I <= C.maxY; ++I) {
+          if (p && !c.tileCoordIntersectsViewport([f, E, I], S))
+            continue;
+          const L = this.getTile(f, E, I, e);
+          if (!L || !se(i, L, f))
+            continue;
+          const y = L.getKey();
+          if (u[y] = !0, L.getState() === T.IDLE && !e.tileQueue.isKeyQueued(y)) {
+            const Z = ye(f, E, I, this.tempTileCoord_);
+            e.tileQueue.enqueue([
+              L,
+              o,
+              c.getTileCoordCenter(Z),
+              P
+            ]);
+          }
+        }
+    }
+  }
+  /**
+   * Look for tiles covering the provided tile coordinate at an alternate
+   * zoom level.  Loaded tiles will be added to the provided tile texture lookup.
+   * @param {import("../../tilecoord.js").TileCoord} tileCoord The target tile coordinate.
+   * @param {TileLookup} tilesByZ Lookup of tiles by zoom level.
+   * @return {boolean} The tile coordinate is covered by loaded tiles at the alternate zoom level.
+   * @private
+   */
+  findStaleTile_(e, t) {
+    const n = this.tileCache_, i = e[0], r = e[1], a = e[2], s = this.getStaleKeys();
+    for (let l = 0; l < s.length; ++l) {
+      const c = ie(
+        this.getLayer().getSource(),
+        s[l],
+        i,
+        r,
+        a
+      );
+      if (n.containsKey(c)) {
+        const o = n.peek(c);
+        if (o.getState() === T.LOADED)
+          return o.endTransition(z(this)), se(t, o, i), !0;
+      }
+    }
+    return !1;
+  }
+  /**
+   * Look for tiles covering the provided tile coordinate at an alternate
+   * zoom level.  Loaded tiles will be added to the provided tile texture lookup.
+   * @param {import("../../tilegrid/TileGrid.js").default} tileGrid The tile grid.
+   * @param {import("../../tilecoord.js").TileCoord} tileCoord The target tile coordinate.
+   * @param {number} altZ The alternate zoom level.
+   * @param {TileLookup} tilesByZ Lookup of tiles by zoom level.
+   * @return {boolean} The tile coordinate is covered by loaded tiles at the alternate zoom level.
+   * @private
+   */
+  findAltTiles_(e, t, n, i) {
+    const r = e.getTileRangeForTileCoordAndZ(
+      t,
+      n,
+      this.tempTileRange_
+    );
+    if (!r)
+      return !1;
+    let a = !0;
+    const s = this.tileCache_, l = this.getLayer().getRenderSource(), c = l.getKey();
+    for (let o = r.minX; o <= r.maxX; ++o)
+      for (let u = r.minY; u <= r.maxY; ++u) {
+        const h = ie(l, c, n, o, u);
+        let g = !1;
+        if (s.containsKey(h)) {
+          const p = s.peek(h);
+          p.getState() === T.LOADED && (se(i, p, n), g = !0);
+        }
+        g || (a = !1);
+      }
+    return a;
+  }
+  /**
+   * Render the layer.
+   *
+   * The frame rendering logic has three parts:
+   *
+   *  1. Enqueue tiles
+   *  2. Find alt tiles for those that are not yet loaded
+   *  3. Render loaded tiles
+   *
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target that may be used to render content to.
+   * @return {HTMLElement} The rendered element.
+   * @override
+   */
+  renderFrame(e, t) {
+    this.renderComplete = !0;
+    const n = e.layerStatesArray[e.layerIndex], i = e.viewState, r = i.projection, a = i.resolution, s = i.center, l = e.pixelRatio, c = this.getLayer(), o = c.getSource(), u = o.getTileGridForProjection(r), h = u.getZForResolution(a, o.zDirection), g = u.getResolution(h), p = o.getKey();
+    this.renderedSourceKey_ ? this.renderedSourceKey_ !== p && (this.prependStaleKey(this.renderedSourceKey_), this.renderedSourceKey_ = p) : this.renderedSourceKey_ = p;
+    let S = e.extent;
+    const f = o.getTilePixelRatio(l);
+    this.prepareContainer(e, t);
+    const C = this.context.canvas.width, P = this.context.canvas.height, E = n.extent && re(n.extent);
+    E && (S = oe(
+      S,
+      re(n.extent)
+    ));
+    const I = g * C / 2 / f, L = g * P / 2 / f, b = [
+      s[0] - I,
+      s[1] - L,
+      s[0] + I,
+      s[1] + L
+    ], y = {};
+    this.renderedTiles.length = 0;
+    const Z = c.getPreload();
+    if (e.nextExtent) {
+      const x = u.getZForResolution(
+        i.nextResolution,
+        o.zDirection
+      ), R = me(e, e.nextExtent);
+      this.enqueueTiles(e, R, x, y, Z);
+    }
+    const ce = me(e, S);
+    if (this.enqueueTiles(e, ce, h, y, 0), Z > 0 && setTimeout(() => {
+      this.enqueueTiles(
+        e,
+        ce,
+        h - 1,
+        y,
+        Z - 1
+      );
+    }, 0), !(h in y))
+      return this.container;
+    const he = z(this), we = e.time;
+    for (const x of y[h]) {
+      const R = x.getState();
+      if (R === T.EMPTY)
+        continue;
+      const D = x.tileCoord;
+      if (R === T.LOADED && x.getAlpha(he, we) === 1) {
+        x.endTransition(he);
+        continue;
+      }
+      if (R !== T.ERROR && (this.renderComplete = !1), this.findStaleTile_(D, y)) {
+        ct(y, x, h), e.animate = !0;
+        continue;
+      }
+      if (this.findAltTiles_(
+        u,
+        D,
+        h + 1,
+        y
+      ))
+        continue;
+      const k = u.getMinZoom();
+      for (let M = h - 1; M >= k && !this.findAltTiles_(
+        u,
+        D,
+        M,
+        y
+      ); --M)
+        ;
+    }
+    const U = g / a * l / f, _ = this.getRenderContext(e);
+    ae(
+      this.tempTransform,
+      C / 2,
+      P / 2,
+      U,
+      U,
+      0,
+      -C / 2,
+      -P / 2
+    ), n.extent && this.clipUnrotated(_, e, E), o.getInterpolate() || (_.imageSmoothingEnabled = !1), this.preRender(_, e);
+    const G = Object.keys(y).map(Number);
+    G.sort(Ve);
+    let w;
+    const $ = [], de = [];
+    for (let x = G.length - 1; x >= 0; --x) {
+      const R = G[x], D = o.getTilePixelSize(
+        R,
+        l,
+        r
+      ), A = u.getResolution(R) / g, k = D[0] * A * U, M = D[1] * A * U, B = u.getTileCoordForCoordAndZ(
+        Ce(b),
+        R
+      ), ue = u.getTileCoordExtent(B), q = v(this.tempTransform, [
+        f * (ue[0] - b[0]) / g,
+        f * (b[3] - ue[3]) / g
+      ]), ve = f * o.getGutterForProjection(r);
+      for (const N of y[R]) {
+        if (N.getState() !== T.LOADED)
+          continue;
+        const ge = N.tileCoord, fe = B[1] - ge[1], Se = Math.round(q[0] - (fe - 1) * k), _e = B[2] - ge[2], Ie = Math.round(q[1] - (_e - 1) * M), O = Math.round(q[0] - fe * k), K = Math.round(q[1] - _e * M), H = Se - O, V = Ie - K, pe = G.length === 1;
+        let J = !1;
+        w = [O, K, O + H, K, O + H, K + V, O, K + V];
+        for (let W = 0, Le = $.length; W < Le; ++W)
+          if (!pe && R < de[W]) {
+            const m = $[W];
+            We(
+              [O, K, O + H, K + V],
+              [m[0], m[3], m[4], m[7]]
+            ) && (J || (_.save(), J = !0), _.beginPath(), _.moveTo(w[0], w[1]), _.lineTo(w[2], w[3]), _.lineTo(w[4], w[5]), _.lineTo(w[6], w[7]), _.moveTo(m[6], m[7]), _.lineTo(m[4], m[5]), _.lineTo(m[2], m[3]), _.lineTo(m[0], m[1]), _.clip());
+          }
+        $.push(w), de.push(R), this.drawTile(N, e, O, K, H, V, ve, pe), J && _.restore(), this.renderedTiles.unshift(N), this.updateUsedTiles(e.usedTiles, o, N);
+      }
+    }
+    if (this.renderedResolution = g, this.extentChanged = !this.renderedExtent_ || !Xe(this.renderedExtent_, b), this.renderedExtent_ = b, this.renderedPixelRatio = l, this.postRender(this.context, e), n.extent && _.restore(), _.imageSmoothingEnabled = !0, this.renderComplete) {
+      const x = (R, D) => {
+        const Q = z(o), A = D.wantedTiles[Q], k = A ? Object.keys(A).length : 0;
+        this.updateCacheSize(k), this.tileCache_.expireCache();
+      };
+      e.postRenderFunctions.push(x);
+    }
+    return this.container;
+  }
+  /**
+   * Increases the cache size if needed
+   * @param {number} tileCount Minimum number of tiles needed.
+   */
+  updateCacheSize(e) {
+    this.tileCache_.highWaterMark = Math.max(
+      this.tileCache_.highWaterMark,
+      e * 2
+    );
+  }
+  /**
+   * @param {import("../../Tile.js").default} tile Tile.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {number} x Left of the tile.
+   * @param {number} y Top of the tile.
+   * @param {number} w Width of the tile.
+   * @param {number} h Height of the tile.
+   * @param {number} gutter Tile gutter.
+   * @param {boolean} transition Apply an alpha transition.
+   * @protected
+   */
+  drawTile(e, t, n, i, r, a, s, l) {
+    let c;
+    if (e instanceof Re) {
+      if (c = le(e.getData()), !c)
+        throw new Error("Rendering array data is not yet supported");
+    } else
+      c = this.getTileImage(
+        /** @type {import("../../ImageTile.js").default} */
+        e
+      );
+    if (!c)
+      return;
+    const o = this.getRenderContext(t), u = z(this), h = t.layerStatesArray[t.layerIndex], g = h.opacity * (l ? e.getAlpha(u, t.time) : 1), p = g !== o.globalAlpha;
+    p && (o.save(), o.globalAlpha = g), o.drawImage(
+      c,
+      s,
+      s,
+      c.width - 2 * s,
+      c.height - 2 * s,
+      n,
+      i,
+      r,
+      a
+    ), p && o.restore(), g !== h.opacity ? t.animate = !0 : l && e.endTransition(u);
+  }
+  /**
+   * @return {HTMLCanvasElement} Image
+   */
+  getImage() {
+    const e = this.context;
+    return e ? e.canvas : null;
+  }
+  /**
+   * Get the image from a tile.
+   * @param {import("../../ImageTile.js").default} tile Tile.
+   * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
+   * @protected
+   */
+  getTileImage(e) {
+    return e.getImage();
+  }
+  /**
+   * @param {!Object<string, !Object<string, boolean>>} usedTiles Used tiles.
+   * @param {import("../../source/Tile.js").default} tileSource Tile source.
+   * @param {import('../../Tile.js').default} tile Tile.
+   * @protected
+   */
+  updateUsedTiles(e, t, n) {
+    const i = z(t);
+    i in e || (e[i] = {}), e[i][n.getKey()] = !0;
+  }
+}
+const Y = {
+  PRELOAD: "preload",
+  USE_INTERIM_TILES_ON_ERROR: "useInterimTilesOnError"
+};
+class dt extends et {
+  /**
+   * @param {Options<TileSourceType>} [options] Tile layer options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = Object.assign({}, e), n = e.cacheSize;
+    delete e.cacheSize, delete t.preload, delete t.useInterimTilesOnError, super(t), this.on, this.once, this.un, this.cacheSize_ = n, this.setPreload(e.preload !== void 0 ? e.preload : 0), this.setUseInterimTilesOnError(
+      e.useInterimTilesOnError !== void 0 ? e.useInterimTilesOnError : !0
+    );
+  }
+  /**
+   * @return {number|undefined} The suggested cache size
+   * @protected
+   */
+  getCacheSize() {
+    return this.cacheSize_;
+  }
+  /**
+   * Return the level as number to which we will preload tiles up to.
+   * @return {number} The level to preload tiles up to.
+   * @observable
+   * @api
+   */
+  getPreload() {
+    return (
+      /** @type {number} */
+      this.get(Y.PRELOAD)
+    );
+  }
+  /**
+   * Set the level as number to which we will preload tiles up to.
+   * @param {number} preload The level to preload tiles up to.
+   * @observable
+   * @api
+   */
+  setPreload(e) {
+    this.set(Y.PRELOAD, e);
+  }
+  /**
+   * Deprecated.  Whether we use interim tiles on error.
+   * @return {boolean} Use interim tiles on error.
+   * @observable
+   * @api
+   */
+  getUseInterimTilesOnError() {
+    return (
+      /** @type {boolean} */
+      this.get(Y.USE_INTERIM_TILES_ON_ERROR)
+    );
+  }
+  /**
+   * Deprecated.  Set whether we use interim tiles on error.
+   * @param {boolean} useInterimTilesOnError Use interim tiles on error.
+   * @observable
+   * @api
+   */
+  setUseInterimTilesOnError(e) {
+    this.set(Y.USE_INTERIM_TILES_ON_ERROR, e);
+  }
+  /**
+   * Get data for a pixel location.  The return type depends on the source data.  For image tiles,
+   * a four element RGBA array will be returned.  For data tiles, the array length will match the
+   * number of bands in the dataset.  For requests outside the layer extent, `null` will be returned.
+   * Data for a image tiles can only be retrieved if the source's `crossOrigin` property is set.
+   *
+   * ```js
+   * // display layer data on every pointer move
+   * map.on('pointermove', (event) => {
+   *   console.log(layer.getData(event.pixel));
+   * });
+   * ```
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   * @api
+   * @override
+   */
+  getData(e) {
+    return super.getData(e);
+  }
+}
+class ut extends dt {
+  /**
+   * @param {import("./BaseTile.js").Options<TileSourceType>} [options] Tile layer options.
+   */
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * @override
+   */
+  createRenderer() {
+    return new ht(this, {
+      cacheSize: this.getCacheSize()
+    });
+  }
+}
+const xt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: ut
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  lt as C,
+  ut as T,
+  st as Z,
+  ht as a,
+  Y as b,
+  Tt as c,
+  xt as d
+};